Celestin Apprentice 4/Apprentice-Release4.iso/Languages/MPW Oberon 2.1168/OInterfaces/QuickTimeComponents.mod

Text File | 1995-08-10 | 145.6 KB | 3,468 lines | [TEXT/MPS ]

(*
     File:        QuickTimeComponents.mod

     Contains:    QuickTime Interfaces.

     Version:    Technology:    QuickTime 2.0
                 Package:    Universal Interfaces 2.0 in “MPW Latest” on ETO #17

     Copyright:    © 1984-1995 by Apple Computer, Inc.
                 All rights reserved.

     Bugs?:        If you find a problem with this file, use the Apple Bug Reporter
                 stack.  Include the file and version information (from above)
                 in the problem description and send to:
                     Internet:    apple.bugs.applelink.apple.com
                     AppleLink:    APPLE.BUGS

*)

(*$TAGS-*)
(*$CALLING PASCAL*)
MODULE QuickTimeComponents;

IMPORT SYSTEM, Types, Quickdraw, Menus, Components, ImageCompression, Movies,
       Video, Memory, Files, Aliases, Dialogs, Events, QDOffscreen;

(* $PUSH*)
(* $ALIGN MAC68K*)
(* $LibExport+*)

CONST
    clockComponentType*            = LONG("clok");
    systemTickClock*                = LONG("tick");                        (* subtype*: 60ths since boot        *)
    systemSecondClock*            = LONG("seco");                        (* subtype*: seconds since 1904        *)
    systemMillisecondClock*        = LONG("mill");                        (* subtype*: 1000ths since boot        *)
    systemMicrosecondClock*        = LONG("micr");

    kClockRateIsLinear*            = 1;
    kClockImplementsCallBacks*    = 2;

(** These are Clock procedures **)

PROCEDURE ClockGetTime*(aClock: Components.ComponentInstance; VAR out: Movies.TimeRecord): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $1, $7000, $A82A;
    (*$END*)
PROCEDURE ClockNewCallBack*(aClock: Components.ComponentInstance; tb: Movies.TimeBase; callBackType: INTEGER): Movies.QTCallBack;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $6, $2, $7000, $A82A;
    (*$END*)
PROCEDURE ClockDisposeCallBack*(aClock: Components.ComponentInstance; cb: Movies.QTCallBack): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $3, $7000, $A82A;
    (*$END*)
PROCEDURE ClockCallMeWhen*(aClock: Components.ComponentInstance; cb: Movies.QTCallBack; param1: LONGINT; param2: LONGINT; param3: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $10, $4, $7000, $A82A;
    (*$END*)
PROCEDURE ClockCancelCallBack*(aClock: Components.ComponentInstance; cb: Movies.QTCallBack): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $5, $7000, $A82A;
    (*$END*)
PROCEDURE ClockRateChanged*(aClock: Components.ComponentInstance; cb: Movies.QTCallBack): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $6, $7000, $A82A;
    (*$END*)
PROCEDURE ClockTimeChanged*(aClock: Components.ComponentInstance; cb: Movies.QTCallBack): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $7, $7000, $A82A;
    (*$END*)
PROCEDURE ClockSetTimeBase*(aClock: Components.ComponentInstance; tb: Movies.TimeBase): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $8, $7000, $A82A;
    (*$END*)
PROCEDURE ClockStartStopChanged*(aClock: Components.ComponentInstance; cb: Movies.QTCallBack; startChanged: BOOLEAN; stopChanged: BOOLEAN): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $9, $7000, $A82A;
    (*$END*)
PROCEDURE ClockGetRate*(aClock: Components.ComponentInstance; VAR rate: Types.Fixed): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $A, $7000, $A82A;
    (*$END*)

CONST
    kClockGetTimeSelect*            = $1;
    kClockNewCallBackSelect*        = $2;
    kClockDisposeCallBackSelect*    = $3;
    kClockCallMeWhenSelect*        = $4;
    kClockCancelCallBackSelect*    = $5;
    kClockRateChangedSelect*        = $6;
    kClockTimeChangedSelect*        = $7;
    kClockSetTimeBaseSelect*        = $8;
    kClockStartStopChangedSelect* = $9;
    kClockGetRateSelect*            = $A;

(*
    General Sequence Grab stuff
*)

TYPE
    SeqGrabComponent* = Components.ComponentInstance;

    SGChannel* = Components.ComponentInstance;


CONST
    SeqGrabComponentType*        = LONG("barg");
    SeqGrabChannelType*            = LONG("sgch");
    SeqGrabPanelType*            = LONG("sgpn");
    SeqGrabCompressionPanelType*    = LONG("comp");
    SeqGrabSourcePanelType*        = LONG("sour");

    seqGrabToDisk*                = 1;
    seqGrabToMemory*                = 2;
    seqGrabDontUseTempMemory*    = 4;
    seqGrabAppendToFile*            = 8;
    seqGrabDontAddMovieResource*    = 16;
    seqGrabDontMakeMovie*        = 32;
    seqGrabPreExtendFile*        = 64;
    seqGrabDataProcIsInterruptSafe* = 128;
    seqGrabDataProcDoesOverlappingReads* = 256;


TYPE
    SeqGrabDataOutputEnum* = LONGINT;


CONST
    seqGrabRecord*                = 1;
    seqGrabPreview*                = 2;
    seqGrabPlayDuringRecord*        = 4;


TYPE
    SeqGrabUsageEnum* = LONGINT;


CONST
    seqGrabHasBounds*            = 1;
    seqGrabHasVolume*            = 2;
    seqGrabHasDiscreteSamples*    = 4;


TYPE
    SeqGrabChannelInfoEnum* = LONGINT;

    SeqGrabFrameInfo* = RECORD
        frameOffset*:            LONGINT;
        frameTime*:                LONGINT;
        frameSize*:                LONGINT;
        frameChannel*:            SGChannel;
        frameRefCon*:            LONGINT;
    END;

    SeqGrabFrameInfoPtr* = POINTER TO SeqGrabFrameInfo;


CONST
    grabPictOffScreen*            = 1;
    grabPictIgnoreClip*            = 2;
    grabPictCurrentImage*        = 4;

    sgFlagControlledGrab*        = ASH(1,0);

TYPE
    SGDataProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (c: SGChannel; p: Types.Ptr; len: LONGINT; VAR offset: LONGINT; chRefCon: LONGINT; time: Movies.TimeValue; writeType: INTEGER; refCon: LONGINT): Types.OSErr;
    SGDataUPP* = Types.UniversalProcPtr;

    SGDeviceName* = RECORD
        name*:                    Types.Str63;
        icon*:                    Types.Handle;
        flags*:                    LONGINT;
        refCon*:                    LONGINT;
        reserved*:                LONGINT;                                (* zero*)
    END;


CONST
    sgDeviceNameFlagDeviceUnavailable* = ASH(1,0);


TYPE
    SGDeviceListRecord* = RECORD
        count*:                    INTEGER;
        selectedIndex*:            INTEGER;
        reserved*:                LONGINT;                                (* zero*)
        entry*:                    ARRAY 1 (*ΔΔ[0..0]ΔΔ*) OF SGDeviceName;
    END;

    SGDeviceListPtr* = POINTER TO SGDeviceListRecord;
    SGDeviceList* = HANDLE TO SGDeviceListRecord (*ΔΔ POINTER TO SGDeviceListPtr*);


CONST
    sgDeviceListWithIcons*        = ASH(1,0);
    sgDeviceListDontCheckAvailability* = ASH(1,1);

    seqGrabWriteAppend*            = 0;
    seqGrabWriteReserve*            = 1;
    seqGrabWriteFill*            = 2;

    seqGrabUnpause*                = 0;
    seqGrabPause*                = 1;
    seqGrabPauseForMenu*            = 3;

    channelFlagDontOpenResFile*    = 2;
    channelFlagHasDependency*    = 4;

TYPE
    SGModalFilterProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (theDialog: Dialogs.DialogPtr; VAR theEvent: Events.EventRecord; VAR itemHit: INTEGER; refCon: LONGINT): BOOLEAN;
    SGModalFilterUPP* = Types.UniversalProcPtr;


CONST
    sgPanelFlagForPanel*            = 1;


TYPE
    SGOutputRecord* = RECORD
        data*:                    ARRAY 1 (*ΔΔ[0..0]ΔΔ*) OF LONGINT;
    END;

    SGOutput* = POINTER TO SGOutputRecord;


CONST
    channelPlayNormal*            = 0;
    channelPlayFast*                = 1;
    channelPlayHighQuality*        = 2;
    channelPlayAllData*            = 4;


PROCEDURE SGInitialize*(s: SeqGrabComponent): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, 0, $1, $7000, $A82A;
    (*$END*)
PROCEDURE SGSetDataOutput*(s: SeqGrabComponent; (*CONST*)VAR movieFile: Files.FSSpec; whereFlags: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $2, $7000, $A82A;
    (*$END*)
PROCEDURE SGGetDataOutput*(s: SeqGrabComponent; VAR movieFile: Files.FSSpec; VAR whereFlags: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $3, $7000, $A82A;
    (*$END*)
PROCEDURE SGSetGWorld*(s: SeqGrabComponent; gp: Quickdraw.CGrafPtr; gd: Quickdraw.GDHandle): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $4, $7000, $A82A;
    (*$END*)
PROCEDURE SGGetGWorld*(s: SeqGrabComponent; VAR gp: Quickdraw.CGrafPtr; VAR gd: Quickdraw.GDHandle): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $5, $7000, $A82A;
    (*$END*)
PROCEDURE SGNewChannel*(s: SeqGrabComponent; channelType: Types.OSType; VAR ref: SGChannel): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $6, $7000, $A82A;
    (*$END*)
PROCEDURE SGDisposeChannel*(s: SeqGrabComponent; c: SGChannel): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $7, $7000, $A82A;
    (*$END*)
PROCEDURE SGStartPreview*(s: SeqGrabComponent): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, 0, $10, $7000, $A82A;
    (*$END*)
PROCEDURE SGStartRecord*(s: SeqGrabComponent): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, 0, $11, $7000, $A82A;
    (*$END*)
PROCEDURE SGIdle*(s: SeqGrabComponent): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, 0, $12, $7000, $A82A;
    (*$END*)
PROCEDURE SGStop*(s: SeqGrabComponent): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, 0, $13, $7000, $A82A;
    (*$END*)
PROCEDURE SGPause*(s: SeqGrabComponent; pause: Types.ByteParameter): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $2, $14, $7000, $A82A;
    (*$END*)
PROCEDURE SGPrepare*(s: SeqGrabComponent; prepareForPreview: BOOLEAN; prepareForRecord: BOOLEAN): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $15, $7000, $A82A;
    (*$END*)
PROCEDURE SGRelease*(s: SeqGrabComponent): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, 0, $16, $7000, $A82A;
    (*$END*)
PROCEDURE SGGetMovie*(s: SeqGrabComponent): Movies.Movie;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, 0, $17, $7000, $A82A;
    (*$END*)
PROCEDURE SGSetMaximumRecordTime*(s: SeqGrabComponent; ticks: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $18, $7000, $A82A;
    (*$END*)
PROCEDURE SGGetMaximumRecordTime*(s: SeqGrabComponent; VAR ticks: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $19, $7000, $A82A;
    (*$END*)
PROCEDURE SGGetStorageSpaceRemaining*(s: SeqGrabComponent; VAR bytes: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $1A, $7000, $A82A;
    (*$END*)
PROCEDURE SGGetTimeRemaining*(s: SeqGrabComponent; VAR ticksLeft: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $1B, $7000, $A82A;
    (*$END*)
PROCEDURE SGGrabPict*(s: SeqGrabComponent; VAR p: Quickdraw.PicHandle; (*CONST*)VAR bounds: Types.Rect; offscreenDepth: INTEGER; grabPictFlags: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $E, $1C, $7000, $A82A;
    (*$END*)
PROCEDURE SGGetLastMovieResID*(s: SeqGrabComponent; VAR resID: INTEGER): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $1D, $7000, $A82A;
    (*$END*)
PROCEDURE SGSetFlags*(s: SeqGrabComponent; sgFlags: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $1E, $7000, $A82A;
    (*$END*)
PROCEDURE SGGetFlags*(s: SeqGrabComponent; VAR sgFlags: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $1F, $7000, $A82A;
    (*$END*)
PROCEDURE SGSetDataProc*(s: SeqGrabComponent; proc: SGDataUPP; refCon: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $20, $7000, $A82A;
    (*$END*)
PROCEDURE SGNewChannelFromComponent*(s: SeqGrabComponent; VAR newChannel: SGChannel; sgChannelComponent: Components.Component): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $21, $7000, $A82A;
    (*$END*)
PROCEDURE SGDisposeDeviceList*(s: SeqGrabComponent; list: SGDeviceList): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $22, $7000, $A82A;
    (*$END*)
PROCEDURE SGAppendDeviceListToMenu*(s: SeqGrabComponent; list: SGDeviceList; mh: Menus.MenuHandle): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $23, $7000, $A82A;
    (*$END*)
PROCEDURE SGSetSettings*(s: SeqGrabComponent; ud: Movies.UserData; flags: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $24, $7000, $A82A;
    (*$END*)
PROCEDURE SGGetSettings*(s: SeqGrabComponent; VAR ud: Movies.UserData; flags: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $25, $7000, $A82A;
    (*$END*)
PROCEDURE SGGetIndChannel*(s: SeqGrabComponent; index: INTEGER; VAR ref: SGChannel; VAR chanType: Types.OSType): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $A, $26, $7000, $A82A;
    (*$END*)
PROCEDURE SGUpdate*(s: SeqGrabComponent; updateRgn: Quickdraw.RgnHandle): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $27, $7000, $A82A;
    (*$END*)
PROCEDURE SGGetPause*(s: SeqGrabComponent; VAR paused: Types.Byte): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $28, $7000, $A82A;
    (*$END*)
PROCEDURE SGSettingsDialog*(s: SeqGrabComponent; c: SGChannel; numPanels: INTEGER; VAR panelList: Components.Component; flags: LONGINT; proc: SGModalFilterUPP; procRefNum: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $16, $29, $7000, $A82A;
    (*$END*)
PROCEDURE SGGetAlignmentProc*(s: SeqGrabComponent; alignmentProc: ImageCompression.ICMAlignmentProcRecordPtr): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $2A, $7000, $A82A;
    (*$END*)
PROCEDURE SGSetChannelSettings*(s: SeqGrabComponent; c: SGChannel; ud: Movies.UserData; flags: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $2B, $7000, $A82A;
    (*$END*)
PROCEDURE SGGetChannelSettings*(s: SeqGrabComponent; c: SGChannel; VAR ud: Movies.UserData; flags: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $2C, $7000, $A82A;
    (*$END*)
PROCEDURE SGGetMode*(s: SeqGrabComponent; VAR previewMode: BOOLEAN; VAR recordMode: BOOLEAN): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $2D, $7000, $A82A;
    (*$END*)
PROCEDURE SGSetDataRef*(s: SeqGrabComponent; dataRef: Types.Handle; dataRefType: Types.OSType; whereFlags: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $2E, $7000, $A82A;
    (*$END*)
PROCEDURE SGGetDataRef*(s: SeqGrabComponent; VAR dataRef: Types.Handle; VAR dataRefType: Types.OSType; VAR whereFlags: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $2F, $7000, $A82A;
    (*$END*)
PROCEDURE SGNewOutput*(s: SeqGrabComponent; dataRef: Types.Handle; dataRefType: Types.OSType; whereFlags: LONGINT; VAR output: SGOutput): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $10, $30, $7000, $A82A;
    (*$END*)
PROCEDURE SGDisposeOutput*(s: SeqGrabComponent; output: SGOutput): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $31, $7000, $A82A;
    (*$END*)
PROCEDURE SGSetOutputFlags*(s: SeqGrabComponent; output: SGOutput; whereFlags: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $32, $7000, $A82A;
    (*$END*)
PROCEDURE SGSetChannelOutput*(s: SeqGrabComponent; c: SGChannel; output: SGOutput): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $33, $7000, $A82A;
    (*$END*)
PROCEDURE SGGetDataOutputStorageSpaceRemaining*(s: SeqGrabComponent; output: SGOutput; VAR space: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $34, $7000, $A82A;
    (*$END*)
(*
    calls from Channel to seqGrab
*)
PROCEDURE SGWriteMovieData*(s: SeqGrabComponent; c: SGChannel; p: Types.Ptr; len: LONGINT; VAR offset: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $10, $100, $7000, $A82A;
    (*$END*)
PROCEDURE SGAddFrameReference*(s: SeqGrabComponent; frameInfo: SeqGrabFrameInfoPtr): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $101, $7000, $A82A;
    (*$END*)
PROCEDURE SGGetNextFrameReference*(s: SeqGrabComponent; frameInfo: SeqGrabFrameInfoPtr; VAR frameDuration: Movies.TimeValue; VAR frameNumber: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $102, $7000, $A82A;
    (*$END*)
PROCEDURE SGGetTimeBase*(s: SeqGrabComponent; VAR tb: Movies.TimeBase): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $103, $7000, $A82A;
    (*$END*)
PROCEDURE SGSortDeviceList*(s: SeqGrabComponent; list: SGDeviceList): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $104, $7000, $A82A;
    (*$END*)
PROCEDURE SGAddMovieData*(s: SeqGrabComponent; c: SGChannel; p: Types.Ptr; len: LONGINT; VAR offset: LONGINT; chRefCon: LONGINT; time: Movies.TimeValue; writeType: INTEGER): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $1A, $105, $7000, $A82A;
    (*$END*)
PROCEDURE SGChangedSource*(s: SeqGrabComponent; c: SGChannel): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $106, $7000, $A82A;
    (*$END*)
(*** Sequence Grab CHANNEL Components.Component Stuff ***)
PROCEDURE SGSetChannelUsage*(c: SGChannel; usage: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $80, $7000, $A82A;
    (*$END*)
PROCEDURE SGGetChannelUsage*(c: SGChannel; VAR usage: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $81, $7000, $A82A;
    (*$END*)
PROCEDURE SGSetChannelBounds*(c: SGChannel; (*CONST*)VAR bounds: Types.Rect): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $82, $7000, $A82A;
    (*$END*)
PROCEDURE SGGetChannelBounds*(c: SGChannel; VAR bounds: Types.Rect): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $83, $7000, $A82A;
    (*$END*)
PROCEDURE SGSetChannelVolume*(c: SGChannel; volume: INTEGER): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $2, $84, $7000, $A82A;
    (*$END*)
PROCEDURE SGGetChannelVolume*(c: SGChannel; VAR volume: INTEGER): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $85, $7000, $A82A;
    (*$END*)
PROCEDURE SGGetChannelInfo*(c: SGChannel; VAR channelInfo: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $86, $7000, $A82A;
    (*$END*)
PROCEDURE SGSetChannelPlayFlags*(c: SGChannel; playFlags: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $87, $7000, $A82A;
    (*$END*)
PROCEDURE SGGetChannelPlayFlags*(c: SGChannel; VAR playFlags: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $88, $7000, $A82A;
    (*$END*)
PROCEDURE SGSetChannelMaxFrames*(c: SGChannel; frameCount: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $89, $7000, $A82A;
    (*$END*)
PROCEDURE SGGetChannelMaxFrames*(c: SGChannel; VAR frameCount: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $8A, $7000, $A82A;
    (*$END*)
PROCEDURE SGSetChannelRefCon*(c: SGChannel; refCon: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $8B, $7000, $A82A;
    (*$END*)
PROCEDURE SGSetChannelClip*(c: SGChannel; theClip: Quickdraw.RgnHandle): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $8C, $7000, $A82A;
    (*$END*)
PROCEDURE SGGetChannelClip*(c: SGChannel; VAR theClip: Quickdraw.RgnHandle): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $8D, $7000, $A82A;
    (*$END*)
PROCEDURE SGGetChannelSampleDescription*(c: SGChannel; sampleDesc: Types.Handle): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $8E, $7000, $A82A;
    (*$END*)
PROCEDURE SGGetChannelDeviceList*(c: SGChannel; selectionFlags: LONGINT; VAR list: SGDeviceList): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $8F, $7000, $A82A;
    (*$END*)
PROCEDURE SGSetChannelDevice*(c: SGChannel; name: Types.StringPtr): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $90, $7000, $A82A;
    (*$END*)
PROCEDURE SGSetChannelMatrix*(c: SGChannel; (*CONST*)VAR m: ImageCompression.MatrixRecord): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $91, $7000, $A82A;
    (*$END*)
PROCEDURE SGGetChannelMatrix*(c: SGChannel; VAR m: ImageCompression.MatrixRecord): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $92, $7000, $A82A;
    (*$END*)
PROCEDURE SGGetChannelTimeScale*(c: SGChannel; VAR scale: Movies.TimeScale): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $93, $7000, $A82A;
    (*$END*)
PROCEDURE SGChannelPutPicture*(c: SGChannel): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, 0, $94, $7000, $A82A;
    (*$END*)
PROCEDURE SGChannelSetRequestedDataRate*(c: SGChannel; bytesPerSecond: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $95, $7000, $A82A;
    (*$END*)
PROCEDURE SGChannelGetRequestedDataRate*(c: SGChannel; VAR bytesPerSecond: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $96, $7000, $A82A;
    (*$END*)
PROCEDURE SGChannelSetDataSourceName*(c: SGChannel; name: Types.ConstStr255Param; scriptTag: Types.ScriptCode): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $6, $97, $7000, $A82A;
    (*$END*)
PROCEDURE SGChannelGetDataSourceName*(c: SGChannel; VAR name: Types.Str255; VAR scriptTag: Types.ScriptCode): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $98, $7000, $A82A;
    (*$END*)
(*
    calls from seqGrab to Channel
*)
PROCEDURE SGInitChannel*(c: SGChannel; owner: SeqGrabComponent): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $180, $7000, $A82A;
    (*$END*)
PROCEDURE SGWriteSamples*(c: SGChannel; m: Movies.Movie; theFile: Aliases.AliasHandle): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $181, $7000, $A82A;
    (*$END*)
PROCEDURE SGGetDataRate*(c: SGChannel; VAR bytesPerSecond: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $182, $7000, $A82A;
    (*$END*)
PROCEDURE SGAlignChannelRect*(c: SGChannel; VAR r: Types.Rect): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $183, $7000, $A82A;
    (*$END*)
(*
    Dorky dialog panel calls
*)
PROCEDURE SGPanelGetDitl*(s: SeqGrabComponent; VAR ditl: Types.Handle): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $200, $7000, $A82A;
    (*$END*)
PROCEDURE SGPanelGetTitle*(s: SeqGrabComponent; VAR title: Types.Str255): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $201, $7000, $A82A;
    (*$END*)
PROCEDURE SGPanelCanRun*(s: SeqGrabComponent; c: SGChannel): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $202, $7000, $A82A;
    (*$END*)
PROCEDURE SGPanelInstall*(s: SeqGrabComponent; c: SGChannel; d: Dialogs.DialogPtr; itemOffset: INTEGER): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $A, $203, $7000, $A82A;
    (*$END*)
PROCEDURE SGPanelEvent*(s: SeqGrabComponent; c: SGChannel; d: Dialogs.DialogPtr; itemOffset: INTEGER; VAR theEvent: Events.EventRecord; VAR itemHit: INTEGER; VAR handled: BOOLEAN): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $16, $204, $7000, $A82A;
    (*$END*)
PROCEDURE SGPanelItem*(s: SeqGrabComponent; c: SGChannel; d: Dialogs.DialogPtr; itemOffset: INTEGER; itemNum: INTEGER): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $205, $7000, $A82A;
    (*$END*)
PROCEDURE SGPanelRemove*(s: SeqGrabComponent; c: SGChannel; d: Dialogs.DialogPtr; itemOffset: INTEGER): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $A, $206, $7000, $A82A;
    (*$END*)
PROCEDURE SGPanelSetGrabber*(s: SeqGrabComponent; sg: SeqGrabComponent): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $207, $7000, $A82A;
    (*$END*)
PROCEDURE SGPanelSetResFile*(s: SeqGrabComponent; resRef: INTEGER): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $2, $208, $7000, $A82A;
    (*$END*)
PROCEDURE SGPanelGetSettings*(s: SeqGrabComponent; c: SGChannel; VAR ud: Movies.UserData; flags: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $209, $7000, $A82A;
    (*$END*)
PROCEDURE SGPanelSetSettings*(s: SeqGrabComponent; c: SGChannel; ud: Movies.UserData; flags: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $20A, $7000, $A82A;
    (*$END*)
PROCEDURE SGPanelValidateInput*(s: SeqGrabComponent; VAR ok: BOOLEAN): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $20B, $7000, $A82A;
    (*$END*)
PROCEDURE SGPanelSetEventFilter*(s: SeqGrabComponent; proc: SGModalFilterUPP; refCon: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $20C, $7000, $A82A;
    (*$END*)
(*** Sequence Grab VIDEO CHANNEL Components.Component Stuff ***)
(*
    Video stuff
*)

TYPE
    SGCompressInfo* = RECORD
        buffer*:                    Types.Ptr;
        bufferSize*:                LONGINT;
        similarity*:                Types.SInt8; (* UInt8 *)
        reserved*:                Types.SInt8; (* UInt8 *)
    END;

    SGGrabProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (c: SGChannel; bufferNum: INTEGER; refCon: LONGINT): Components.ComponentResult;
    SGGrabCompleteProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (c: SGChannel; bufferNum: INTEGER; VAR done: BOOLEAN; refCon: LONGINT): Components.ComponentResult;
    SGDisplayProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (c: SGChannel; bufferNum: INTEGER; VAR mp: ImageCompression.MatrixRecord; clipRgn: Quickdraw.RgnHandle; refCon: LONGINT): Components.ComponentResult;
    SGCompressProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (c: SGChannel; bufferNum: INTEGER; refCon: LONGINT): Components.ComponentResult;
    SGCompressCompleteProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (c: SGChannel; bufferNum: INTEGER; VAR done: BOOLEAN; VAR ci: SGCompressInfo; refCon: LONGINT): Components.ComponentResult;
    SGAddFrameProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (c: SGChannel; bufferNum: INTEGER; atTime: Movies.TimeValue; scale: Movies.TimeScale; (*CONST*)VAR ci: SGCompressInfo; refCon: LONGINT): Components.ComponentResult;
    SGTransferFrameProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (c: SGChannel; bufferNum: INTEGER; VAR mp: ImageCompression.MatrixRecord; clipRgn: Quickdraw.RgnHandle; refCon: LONGINT): Components.ComponentResult;
    SGGrabCompressCompleteProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (c: SGChannel; VAR done: BOOLEAN; VAR ci: SGCompressInfo; VAR t: Movies.TimeRecord; refCon: LONGINT): Components.ComponentResult;
    SGDisplayCompressProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (c: SGChannel; dataPtr: Types.Ptr; desc: ImageCompression.ImageDescriptionHandle; VAR mp: ImageCompression.MatrixRecord; clipRgn: Quickdraw.RgnHandle; refCon: LONGINT): Components.ComponentResult;
    SGGrabUPP* = Types.UniversalProcPtr;
    SGGrabCompleteUPP* = Types.UniversalProcPtr;
    SGDisplayUPP* = Types.UniversalProcPtr;
    SGCompressUPP* = Types.UniversalProcPtr;
    SGCompressCompleteUPP* = Types.UniversalProcPtr;
    SGAddFrameUPP* = Types.UniversalProcPtr;
    SGTransferFrameUPP* = Types.UniversalProcPtr;
    SGGrabCompressCompleteUPP* = Types.UniversalProcPtr;
    SGDisplayCompressUPP* = Types.UniversalProcPtr;

    VideoBottles* = RECORD
        procCount*:                INTEGER;
        grabProc*:                SGGrabUPP;
        grabCompleteProc*:        SGGrabCompleteUPP;
        displayProc*:            SGDisplayUPP;
        compressProc*:            SGCompressUPP;
        compressCompleteProc*:    SGCompressCompleteUPP;
        addFrameProc*:            SGAddFrameUPP;
        transferFrameProc*:        SGTransferFrameUPP;
        grabCompressCompleteProc*: SGGrabCompressCompleteUPP;
        displayCompressProc*:    SGDisplayCompressUPP;
    END;


PROCEDURE SGGetSrcVideoBounds*(c: SGChannel; VAR r: Types.Rect): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $100, $7000, $A82A;
    (*$END*)
PROCEDURE SGSetVideoRect*(c: SGChannel; (*CONST*)VAR r: Types.Rect): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $101, $7000, $A82A;
    (*$END*)
PROCEDURE SGGetVideoRect*(c: SGChannel; VAR r: Types.Rect): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $102, $7000, $A82A;
    (*$END*)
PROCEDURE SGGetVideoCompressorType*(c: SGChannel; VAR compressorType: Types.OSType): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $103, $7000, $A82A;
    (*$END*)
PROCEDURE SGSetVideoCompressorType*(c: SGChannel; compressorType: Types.OSType): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $104, $7000, $A82A;
    (*$END*)
PROCEDURE SGSetVideoCompressor*(c: SGChannel; depth: INTEGER; compressor: ImageCompression.CompressorComponent; spatialQuality: ImageCompression.CodecQ; temporalQuality: ImageCompression.CodecQ; keyFrameRate: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $12, $105, $7000, $A82A;
    (*$END*)
PROCEDURE SGGetVideoCompressor*(c: SGChannel; VAR depth: INTEGER; VAR compressor: ImageCompression.CompressorComponent; VAR spatialQuality: ImageCompression.CodecQ; VAR temporalQuality: ImageCompression.CodecQ; VAR keyFrameRate: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $14, $106, $7000, $A82A;
    (*$END*)
PROCEDURE SGGetVideoDigitizerComponent*(c: SGChannel): Components.ComponentInstance;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, 0, $107, $7000, $A82A;
    (*$END*)
PROCEDURE SGSetVideoDigitizerComponent*(c: SGChannel; vdig: Components.ComponentInstance): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $108, $7000, $A82A;
    (*$END*)
PROCEDURE SGVideoDigitizerChanged*(c: SGChannel): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, 0, $109, $7000, $A82A;
    (*$END*)
PROCEDURE SGSetVideoBottlenecks*(c: SGChannel; VAR vb: VideoBottles): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $10A, $7000, $A82A;
    (*$END*)
PROCEDURE SGGetVideoBottlenecks*(c: SGChannel; VAR vb: VideoBottles): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $10B, $7000, $A82A;
    (*$END*)
PROCEDURE SGGrabFrame*(c: SGChannel; bufferNum: INTEGER): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $2, $10C, $7000, $A82A;
    (*$END*)
PROCEDURE SGGrabFrameComplete*(c: SGChannel; bufferNum: INTEGER; VAR done: BOOLEAN): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $6, $10D, $7000, $A82A;
    (*$END*)
PROCEDURE SGDisplayFrame*(c: SGChannel; bufferNum: INTEGER; (*CONST*)VAR mp: ImageCompression.MatrixRecord; clipRgn: Quickdraw.RgnHandle): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $A, $10E, $7000, $A82A;
    (*$END*)
PROCEDURE SGCompressFrame*(c: SGChannel; bufferNum: INTEGER): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $2, $10F, $7000, $A82A;
    (*$END*)
PROCEDURE SGCompressFrameComplete*(c: SGChannel; bufferNum: INTEGER; VAR done: BOOLEAN; VAR ci: SGCompressInfo): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $A, $110, $7000, $A82A;
    (*$END*)
PROCEDURE SGAddFrame*(c: SGChannel; bufferNum: INTEGER; atTime: Movies.TimeValue; scale: Movies.TimeScale; (*CONST*)VAR ci: SGCompressInfo): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $E, $111, $7000, $A82A;
    (*$END*)
PROCEDURE SGTransferFrameForCompress*(c: SGChannel; bufferNum: INTEGER; (*CONST*)VAR mp: ImageCompression.MatrixRecord; clipRgn: Quickdraw.RgnHandle): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $A, $112, $7000, $A82A;
    (*$END*)
PROCEDURE SGSetCompressBuffer*(c: SGChannel; depth: INTEGER; (*CONST*)VAR compressSize: Types.Rect): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $6, $113, $7000, $A82A;
    (*$END*)
PROCEDURE SGGetCompressBuffer*(c: SGChannel; VAR depth: INTEGER; VAR compressSize: Types.Rect): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $114, $7000, $A82A;
    (*$END*)
PROCEDURE SGGetBufferInfo*(c: SGChannel; bufferNum: INTEGER; VAR bufferPM: Quickdraw.PixMapHandle; VAR bufferRect: Types.Rect; VAR compressBuffer: QDOffscreen.GWorldPtr; VAR compressBufferRect: Types.Rect): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $12, $115, $7000, $A82A;
    (*$END*)
PROCEDURE SGSetUseScreenBuffer*(c: SGChannel; useScreenBuffer: BOOLEAN): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $2, $116, $7000, $A82A;
    (*$END*)
PROCEDURE SGGetUseScreenBuffer*(c: SGChannel; VAR useScreenBuffer: BOOLEAN): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $117, $7000, $A82A;
    (*$END*)
PROCEDURE SGGrabCompressComplete*(c: SGChannel; VAR done: BOOLEAN; VAR ci: SGCompressInfo; VAR tr: Movies.TimeRecord): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $118, $7000, $A82A;
    (*$END*)
PROCEDURE SGDisplayCompress*(c: SGChannel; dataPtr: Types.Ptr; desc: ImageCompression.ImageDescriptionHandle; VAR mp: ImageCompression.MatrixRecord; clipRgn: Quickdraw.RgnHandle): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $10, $119, $7000, $A82A;
    (*$END*)
PROCEDURE SGSetFrameRate*(c: SGChannel; frameRate: Types.Fixed): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $11A, $7000, $A82A;
    (*$END*)
PROCEDURE SGGetFrameRate*(c: SGChannel; VAR frameRate: Types.Fixed): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $11B, $7000, $A82A;
    (*$END*)
(*** Sequence Grab SOUND CHANNEL Components.Component Stuff ***)
(*
    Sound stuff
*)
PROCEDURE SGSetSoundInputDriver*(c: SGChannel; driverName: Types.ConstStr255Param): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $100, $7000, $A82A;
    (*$END*)
PROCEDURE SGGetSoundInputDriver*(c: SGChannel): LONGINT;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, 0, $101, $7000, $A82A;
    (*$END*)
PROCEDURE SGSoundInputDriverChanged*(c: SGChannel): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, 0, $102, $7000, $A82A;
    (*$END*)
PROCEDURE SGSetSoundRecordChunkSize*(c: SGChannel; seconds: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $103, $7000, $A82A;
    (*$END*)
PROCEDURE SGGetSoundRecordChunkSize*(c: SGChannel): LONGINT;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, 0, $104, $7000, $A82A;
    (*$END*)
PROCEDURE SGSetSoundInputRate*(c: SGChannel; rate: Types.Fixed): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $105, $7000, $A82A;
    (*$END*)
PROCEDURE SGGetSoundInputRate*(c: SGChannel): Types.Fixed;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, 0, $106, $7000, $A82A;
    (*$END*)
PROCEDURE SGSetSoundInputParameters*(c: SGChannel; sampleSize: INTEGER; numChannels: INTEGER; compressionType: Types.OSType): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $107, $7000, $A82A;
    (*$END*)
PROCEDURE SGGetSoundInputParameters*(c: SGChannel; VAR sampleSize: INTEGER; VAR numChannels: INTEGER; VAR compressionType: Types.OSType): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $108, $7000, $A82A;
    (*$END*)

CONST
    sgChannelAtom*                = LONG("chan");
    sgChannelSettingsAtom*        = LONG("ctom");
    sgChannelDescription*        = LONG("cdsc");
    sgChannelSettings*            = LONG("cset");

    sgDeviceNameType*            = LONG("name");
    sgUsageType*                    = LONG("use ");
    sgPlayFlagsType*                = LONG("plyf");
    sgClipType*                    = LONG("clip");
    sgMatrixType*                = LONG("mtrx");
    sgVolumeType*                = LONG("volu");

    sgPanelSettingsAtom*            = LONG("ptom");
    sgPanelDescription*            = LONG("pdsc");
    sgPanelSettings*                = LONG("pset");

    sgcSoundCompressionType*        = LONG("scmp");
    sgcSoundSampleRateType*        = LONG("srat");
    sgcSoundChannelCountType*    = LONG("schn");
    sgcSoundSampleSizeType*        = LONG("ssiz");
    sgcSoundInputType*            = LONG("sinp");
    sgcSoundGainType*            = LONG("gain");

    sgcVideoHueType*                = LONG("hue ");
    sgcVideoSaturationType*        = LONG("satr");
    sgcVideoContrastType*        = LONG("trst");
    sgcVideoSharpnessType*        = LONG("shrp");
    sgcVideoBrigtnessType*        = LONG("brit");
    sgcVideoBlackLevelType*        = LONG("blkl");
    sgcVideoWhiteLevelType*        = LONG("whtl");
    sgcVideoInputType*            = LONG("vinp");
    sgcVideoFormatType*            = LONG("vstd");
    sgcVideoFilterType*            = LONG("vflt");
    sgcVideoRectType*            = LONG("vrct");
    sgVideoDigitizerType*        = LONG("vdig");

    kSGInitializeSelect*            = $1;
    kSGSetDataOutputSelect*        = $2;
    kSGGetDataOutputSelect*        = $3;
    kSGSetGWorldSelect*            = $4;
    kSGGetGWorldSelect*            = $5;
    kSGNewChannelSelect*            = $6;
    kSGDisposeChannelSelect*        = $7;
    kSGStartPreviewSelect*        = $10;
    kSGStartRecordSelect*        = $11;
    kSGIdleSelect*                = $12;
    kSGStopSelect*                = $13;
    kSGPauseSelect*                = $14;
    kSGPrepareSelect*            = $15;
    kSGReleaseSelect*            = $16;
    kSGGetMovieSelect*            = $17;
    kSGSetMaximumRecordTimeSelect* = $18;
    kSGGetMaximumRecordTimeSelect* = $19;
    kSGGetStorageSpaceRemainingSelect* = $1A;
    kSGGetTimeRemainingSelect*    = $1B;
    kSGGrabPictSelect*            = $1C;
    kSGGetLastMovieResIDSelect*    = $1D;
    kSGSetFlagsSelect*            = $1E;
    kSGGetFlagsSelect*            = $1F;
    kSGSetDataProcSelect*        = $20;
    kSGNewChannelFromComponentSelect* = $21;
    kSGDisposeDeviceListSelect*    = $22;
    kSGAppendDeviceListToMenuSelect* = $23;
    kSGSetSettingsSelect*        = $24;
    kSGGetSettingsSelect*        = $25;
    kSGGetIndChannelSelect*        = $26;
    kSGUpdateSelect*                = $27;
    kSGGetPauseSelect*            = $28;
    kSGSettingsDialogSelect*        = $29;
    kSGGetAlignmentProcSelect*    = $2A;
    kSGSetChannelSettingsSelect*    = $2B;
    kSGGetChannelSettingsSelect*    = $2C;
    kSGGetModeSelect*            = $2D;
    kSGSetDataRefSelect*            = $2E;
    kSGGetDataRefSelect*            = $2F;
    kSGNewOutputSelect*            = $30;
    kSGDisposeOutputSelect*        = $31;
    kSGSetOutputFlagsSelect*        = $32;
    kSGSetChannelOutputSelect*    = $33;
    kSGGetDataOutputStorageSpaceRemainingSelect* = $34;
    kSGWriteMovieDataSelect*        = $100;
    kSGAddFrameReferenceSelect*    = $101;
    kSGGetNextFrameReferenceSelect* = $102;
    kSGGetTimeBaseSelect*        = $103;
    kSGSortDeviceListSelect*        = $104;
    kSGAddMovieDataSelect*        = $105;
    kSGChangedSourceSelect*        = $106;
    kSGCSetChannelUsageSelect*    = $80;
    kSGCGetChannelUsageSelect*    = $81;
    kSGCSetChannelBoundsSelect*    = $82;
    kSGCGetChannelBoundsSelect*    = $83;
    kSGCSetChannelVolumeSelect*    = $84;
    kSGCGetChannelVolumeSelect*    = $85;
    kSGCGetChannelInfoSelect*    = $86;
    kSGCSetChannelPlayFlagsSelect* = $87;
    kSGCGetChannelPlayFlagsSelect* = $88;
    kSGCSetChannelMaxFramesSelect* = $89;
    kSGCGetChannelMaxFramesSelect* = $8A;
    kSGCSetChannelRefConSelect*    = $8B;
    kSGCSetChannelClipSelect*    = $8C;
    kSGCGetChannelClipSelect*    = $8D;
    kSGCGetChannelSampleDescriptionSelect* = $8E;
    kSGCGetChannelDeviceListSelect* = $8F;
    kSGCSetChannelDeviceSelect*    = $90;
    kSGCSetChannelMatrixSelect*    = $91;
    kSGCGetChannelMatrixSelect*    = $92;
    kSGCGetChannelTimeScaleSelect* = $93;
    kSGCChannelPutPictureSelect*    = $94;
    kSGCChannelSetRequestedDataRateSelect* = $95;
    kSGCChannelGetRequestedDataRateSelect* = $96;
    kSGCChannelSetDataSourceNameSelect* = $97;
    kSGCChannelGetDataSourceNameSelect* = $98;
    kSGCInitChannelSelect*        = $180;
    kSGCWriteSamplesSelect*        = $181;
    kSGCGetDataRateSelect*        = $182;
    kSGCAlignChannelRectSelect*    = $183;
    kSGCPanelGetDitlSelect*        = $200;
    kSGCPanelGetTitleSelect*        = $201;
    kSGCPanelCanRunSelect*        = $202;
    kSGCPanelInstallSelect*        = $203;
    kSGCPanelEventSelect*        = $204;
    kSGCPanelItemSelect*            = $205;
    kSGCPanelRemoveSelect*        = $206;
    kSGCPanelSetGrabberSelect*    = $207;
    kSGCPanelSetResFileSelect*    = $208;
    kSGCPanelGetSettingsSelect*    = $209;
    kSGCPanelSetSettingsSelect*    = $20A;
    kSGCPanelValidateInputSelect* = $20B;
    kSGCPanelSetEventFilterSelect* = $20C;
    kSGCGetSrcVideoBoundsSelect*    = $100;
    kSGCSetVideoRectSelect*        = $101;
    kSGCGetVideoRectSelect*        = $102;
    kSGCGetVideoCompressorTypeSelect* = $103;
    kSGCSetVideoCompressorTypeSelect* = $104;
    kSGCSetVideoCompressorSelect* = $105;
    kSGCGetVideoCompressorSelect* = $106;
    kSGCGetVideoDigitizerComponentSelect* = $107;
    kSGCSetVideoDigitizerComponentSelect* = $108;
    kSGCVideoDigitizerChangedSelect* = $109;
    kSGCSetVideoBottlenecksSelect* = $10A;
    kSGCGetVideoBottlenecksSelect* = $10B;
    kSGCGrabFrameSelect*            = $10C;
    kSGCGrabFrameCompleteSelect*    = $10D;
    kSGCDisplayFrameSelect*        = $10E;
    kSGCCompressFrameSelect*        = $10F;
    kSGCCompressFrameCompleteSelect* = $110;
    kSGCAddFrameSelect*            = $111;
    kSGCTransferFrameForCompressSelect* = $112;
    kSGCSetCompressBufferSelect*    = $113;
    kSGCGetCompressBufferSelect*    = $114;
    kSGCGetBufferInfoSelect*        = $115;
    kSGCSetUseScreenBufferSelect* = $116;
    kSGCGetUseScreenBufferSelect* = $117;
    kSGCGrabCompressCompleteSelect* = $118;
    kSGCDisplayCompressSelect*    = $119;
    kSGCSetFrameRateSelect*        = $11A;
    kSGCGetFrameRateSelect*        = $11B;
    kSGCSetSoundInputDriverSelect* = $100;
    kSGCGetSoundInputDriverSelect* = $101;
    kSGCSoundInputDriverChangedSelect* = $102;
    kSGCSetSoundRecordChunkSizeSelect* = $103;
    kSGCGetSoundRecordChunkSizeSelect* = $104;
    kSGCSetSoundInputRateSelect*    = $105;
    kSGCGetSoundInputRateSelect*    = $106;
    kSGCSetSoundInputParametersSelect* = $107;
    kSGCGetSoundInputParametersSelect* = $108;

(* Standard type for video digitizers *)
    videoDigitizerComponentType*    = LONG("vdig");
    vdigInterfaceRev*            = 2;

(* Input Format Standards *)
    ntscIn*                        = 0;                            (* current input format *)
    currentIn*                    = 0;                            (* ntsc input format *)
    palIn*                        = 1;                            (* pal input format *)
    secamIn*                        = 2;                            (* secam input format *)
    ntscReallyIn*                = 3;                            (* ntsc input format *)

(* Input Formats *)
    compositeIn*                    = 0;                            (* input is composite format *)
    sVideoIn*                    = 1;                            (* input is sVideo format *)
    rgbComponentIn*                = 2;                            (* input is rgb component format *)
    rgbComponentSyncIn*            = 3;                            (* input is rgb component format (sync on green?)*)
    yuvComponentIn*                = 4;                            (* input is yuv component format *)
    yuvComponentSyncIn*            = 5;                            (* input is yuv component format (sync on green?) *)

(* Video Digitizer PlayThru States *)
    vdPlayThruOff*                = 0;
    vdPlayThruOn*                = 1;

(* Input Color Space Modes *)
    vdDigitizerBW*                = 0;                            (* black and white *)
    vdDigitizerRGB*                = 1;                            (* rgb color *)

(* Phase Lock Loop Modes *)
    vdBroadcastMode*                = 0;                            (* Broadcast / Laser Disk video mode *)
    vdVTRMode*                    = 1;                            (* VCR / Magnetic media mode *)

(* Field Select Options *)
    vdUseAnyField*                = 0;                            (* Digitizers choice on field use *)
    vdUseOddField*                = 1;                            (* Use odd field for half size vert and smaller *)
    vdUseEvenField*                = 2;                            (* Use even field for half size vert and smaller *)

(* vdig types *)
    vdTypeBasic*                    = 0;                            (* basic, no clipping *)
    vdTypeAlpha*                    = 1;                            (* supports clipping with alpha channel *)
    vdTypeMask*                    = 2;                            (* supports clipping with mask plane *)
    vdTypeKey*                    = 3;                            (* supports clipping with key color(s) *)

(* Digitizer Input Capability/Current Flags    *)
    digiInDoesNTSC*                = ASH(1,0);                    (* digitizer supports NTSC input format *)
    digiInDoesPAL*                = ASH(1,1);                    (* digitizer supports PAL input format *)
    digiInDoesSECAM*                = ASH(1,2);                    (* digitizer supports SECAM input format *)
    digiInDoesGenLock*            = ASH(1,7);                    (* digitizer does genlock *)
    digiInDoesComposite*            = ASH(1,8);                    (* digitizer supports composite input type *)
    digiInDoesSVideo*            = ASH(1,9);                    (* digitizer supports S-Video input type *)
    digiInDoesComponent*            = ASH(1,10);                (* digitizer supports component* = rgb, input type *)
    digiInVTR_Broadcast*            = ASH(1,11);                (* digitizer can differentiate between the two *)
    digiInDoesColor*                = ASH(1,12);                (* digitizer supports color *)
    digiInDoesBW*                = ASH(1,13);                (* digitizer supports black & white *)
(* Digitizer Input Current Flags* = these are valid only during active operating conditions,    *)
    digiInSignalLock*            = ASH(1,31);                (* digitizer detects input signal is locked, this bit* = horiz lock || vertical lock *)

(* Digitizer Output Capability/Current Flags *)
    digiOutDoes1*                = ASH(1,0);                    (* digitizer supports 1 bit pixels *)
    digiOutDoes2*                = ASH(1,1);                    (* digitizer supports 2 bit pixels *)
    digiOutDoes4*                = ASH(1,2);                    (* digitizer supports 4 bit pixels *)
    digiOutDoes8*                = ASH(1,3);                    (* digitizer supports 8 bit pixels *)
    digiOutDoes16*                = ASH(1,4);                    (* digitizer supports 16 bit pixels *)
    digiOutDoes32*                = ASH(1,5);                    (* digitizer supports 32 bit pixels *)
    digiOutDoesDither*            = ASH(1,6);                    (* digitizer dithers in indexed modes *)
    digiOutDoesStretch*            = ASH(1,7);                    (* digitizer can arbitrarily stretch *)
    digiOutDoesShrink*            = ASH(1,8);                    (* digitizer can arbitrarily shrink *)
    digiOutDoesMask*                = ASH(1,9);                    (* digitizer can mask to clipping regions *)
    digiOutDoesDouble*            = ASH(1,11);                (* digitizer can stretch to exactly double size *)
    digiOutDoesQuad*                = ASH(1,12);                (* digitizer can stretch exactly quadruple size *)
    digiOutDoesQuarter*            = ASH(1,13);                (* digitizer can shrink to exactly quarter size *)
    digiOutDoesSixteenth*        = ASH(1,14);                (* digitizer can shrink to exactly sixteenth size *)
    digiOutDoesRotate*            = ASH(1,15);                (* digitizer supports rotate transformations *)
    digiOutDoesHorizFlip*        = ASH(1,16);                (* digitizer supports horizontal flips Sx < 0 *)
    digiOutDoesVertFlip*            = ASH(1,17);                (* digitizer supports vertical flips Sy < 0 *)
    digiOutDoesSkew*                = ASH(1,18);                (* digitizer supports skew* = shear,twist, *)
    digiOutDoesBlend*            = ASH(1,19);
    digiOutDoesWarp*                = ASH(1,20);
    digiOutDoesHW_DMA*            = ASH(1,21);                (* digitizer not constrained to local device *)
    digiOutDoesHWPlayThru*        = ASH(1,22);                (* digitizer doesn't need time to play thru *)
    digiOutDoesILUT*                = ASH(1,23);                (* digitizer does inverse LUT for index modes *)
    digiOutDoesKeyColor*            = ASH(1,24);                (* digitizer does key color functions too *)
    digiOutDoesAsyncGrabs*        = ASH(1,25);                (* digitizer supports async grabs *)
    digiOutDoesUnreadableScreenBits* = ASH(1,26);            (* playthru doesn't generate readable bits on screen*)
    digiOutDoesCompress*            = ASH(1,27);                (* supports alternate output data types *)
    digiOutDoesCompressOnly*        = ASH(1,28);                (* can't provide raw frames anywhere *)
    digiOutDoesPlayThruDuringCompress* = ASH(1,29);            (* digi can do playthru while providing compressed data *)

(* Types *)

TYPE
    VideoDigitizerComponent* = Components.ComponentInstance;

    VideoDigitizerError* = Components.ComponentResult;

    DigitizerInfo* = RECORD
        vdigType*:                INTEGER;
        inputCapabilityFlags*:    LONGINT;
        outputCapabilityFlags*:    LONGINT;
        inputCurrentFlags*:        LONGINT;
        outputCurrentFlags*:        LONGINT;
        slot*:                    INTEGER;                                (* temporary for connection purposes *)
        gdh*:                    Quickdraw.GDHandle;                                (* temporary for digitizers that have preferred screen *)
        maskgdh*:                Quickdraw.GDHandle;                                (* temporary for digitizers that have mask planes *)
        minDestHeight*:            INTEGER;                                (* Smallest resizable height *)
        minDestWidth*:            INTEGER;                                (* Smallest resizable width *)
        maxDestHeight*:            INTEGER;                                (* Largest resizable height *)
        maxDestWidth*:            INTEGER;                                (* Largest resizable height *)
        blendLevels*:            INTEGER;                                (* Number of blend levels supported (2 if 1 bit mask) *)
        reserved*:                LONGINT;                                (* reserved *)
    END;

    VdigType* = RECORD
        digType*:                LONGINT;
        reserved*:                LONGINT;
    END;

    VdigTypeList* = RECORD
        count*:                    INTEGER;
        list*:                    ARRAY 1 (*ΔΔ[0..0]ΔΔ*) OF VdigType;
    END;

    VdigBufferRec* = RECORD
        dest*:                    Quickdraw.PixMapHandle;
        location*:                Types.Point;
        reserved*:                LONGINT;
    END;

    VdigBufferRecList* = RECORD
        count*:                    INTEGER;
        matrix*:                    ImageCompression.MatrixRecordPtr;
        mask*:                    Quickdraw.RgnHandle;
        list*:                    ARRAY 1 (*ΔΔ[0..0]ΔΔ*) OF VdigBufferRec;
    END;

    VdigBufferRecListPtr* = POINTER TO VdigBufferRecList;
    VdigBufferRecListHandle* = HANDLE TO VdigBufferRecList (*Δ  POINTER TO VdigBufferRecListPtr*);

    VdigIntProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (flags: LONGINT; refcon: LONGINT);
    VdigIntUPP* = Types.UniversalProcPtr;

    VDCompressionList* = RECORD
        codec*:                    ImageCompression.CodecComponent;
        cType*:                    ImageCompression.CodecType;
        typeName*:                Types.Str63;
        name*:                    Types.Str63;
        formatFlags*:            LONGINT;
        compressFlags*:            LONGINT;
        reserved*:                LONGINT;
    END;

    VDCompressionListPtr* = POINTER TO VDCompressionList;
    VDCompressionListHandle* = HANDLE TO VDCompressionList (*ΔΔ POINTER TO VDCompressionListPtr*);


CONST
    dmaDepth1*                    = 1;
    dmaDepth2*                    = 2;
    dmaDepth4*                    = 4;
    dmaDepth8*                    = 8;
    dmaDepth16*                    = 16;
    dmaDepth32*                    = 32;
    dmaDepth2Gray*                = 64;
    dmaDepth4Gray*                = 128;
    dmaDepth8Gray*                = 256;

    kVDIGControlledFrameRate*    = -1;

(* number of vdig calls*)
    kvdigSelectors*                = 86;


PROCEDURE VDGetMaxSrcRect*(ci: VideoDigitizerComponent; inputStd: INTEGER; VAR maxSrcRect: Types.Rect): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $6, $1, $7000, $A82A;
    (*$END*)
PROCEDURE VDGetActiveSrcRect*(ci: VideoDigitizerComponent; inputStd: INTEGER; VAR activeSrcRect: Types.Rect): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $6, $2, $7000, $A82A;
    (*$END*)
PROCEDURE VDSetDigitizerRect*(ci: VideoDigitizerComponent; VAR digitizerRect: Types.Rect): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $3, $7000, $A82A;
    (*$END*)
PROCEDURE VDGetDigitizerRect*(ci: VideoDigitizerComponent; VAR digitizerRect: Types.Rect): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $4, $7000, $A82A;
    (*$END*)
PROCEDURE VDGetVBlankRect*(ci: VideoDigitizerComponent; inputStd: INTEGER; VAR vBlankRect: Types.Rect): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $6, $5, $7000, $A82A;
    (*$END*)
PROCEDURE VDGetMaskPixMap*(ci: VideoDigitizerComponent; maskPixMap: Quickdraw.PixMapHandle): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $6, $7000, $A82A;
    (*$END*)
PROCEDURE VDGetPlayThruDestination*(ci: VideoDigitizerComponent; VAR dest: Quickdraw.PixMapHandle; VAR destRect: Types.Rect; VAR m: ImageCompression.MatrixRecord; VAR mask: Quickdraw.RgnHandle): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $10, $8, $7000, $A82A;
    (*$END*)
PROCEDURE VDUseThisCLUT*(ci: VideoDigitizerComponent; colorTableHandle: Quickdraw.CTabHandle): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $9, $7000, $A82A;
    (*$END*)
PROCEDURE VDSetInputGammaValue*(ci: VideoDigitizerComponent; channel1: Types.Fixed; channel2: Types.Fixed; channel3: Types.Fixed): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $A, $7000, $A82A;
    (*$END*)
PROCEDURE VDGetInputGammaValue*(ci: VideoDigitizerComponent; VAR channel1: Types.Fixed; VAR channel2: Types.Fixed; VAR channel3: Types.Fixed): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $B, $7000, $A82A;
    (*$END*)
PROCEDURE VDSetBrightness*(ci: VideoDigitizerComponent; VAR brightness: INTEGER): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $C, $7000, $A82A;
    (*$END*)
PROCEDURE VDGetBrightness*(ci: VideoDigitizerComponent; VAR brightness: INTEGER): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $D, $7000, $A82A;
    (*$END*)
PROCEDURE VDSetContrast*(ci: VideoDigitizerComponent; VAR contrast: INTEGER): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $E, $7000, $A82A;
    (*$END*)
PROCEDURE VDSetHue*(ci: VideoDigitizerComponent; VAR hue: INTEGER): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $F, $7000, $A82A;
    (*$END*)
PROCEDURE VDSetSharpness*(ci: VideoDigitizerComponent; VAR sharpness: INTEGER): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $10, $7000, $A82A;
    (*$END*)
PROCEDURE VDSetSaturation*(ci: VideoDigitizerComponent; VAR saturation: INTEGER): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $11, $7000, $A82A;
    (*$END*)
PROCEDURE VDGetContrast*(ci: VideoDigitizerComponent; VAR contrast: INTEGER): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $12, $7000, $A82A;
    (*$END*)
PROCEDURE VDGetHue*(ci: VideoDigitizerComponent; VAR hue: INTEGER): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $13, $7000, $A82A;
    (*$END*)
PROCEDURE VDGetSharpness*(ci: VideoDigitizerComponent; VAR sharpness: INTEGER): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $14, $7000, $A82A;
    (*$END*)
PROCEDURE VDGetSaturation*(ci: VideoDigitizerComponent; VAR saturation: INTEGER): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $15, $7000, $A82A;
    (*$END*)
PROCEDURE VDGrabOneFrame*(ci: VideoDigitizerComponent): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, 0, $16, $7000, $A82A;
    (*$END*)
PROCEDURE VDGetMaxAuxBuffer*(ci: VideoDigitizerComponent; VAR pm: Quickdraw.PixMapHandle; VAR r: Types.Rect): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $17, $7000, $A82A;
    (*$END*)
PROCEDURE VDGetDigitizerInfo*(ci: VideoDigitizerComponent; VAR info: DigitizerInfo): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $19, $7000, $A82A;
    (*$END*)
PROCEDURE VDGetCurrentFlags*(ci: VideoDigitizerComponent; VAR inputCurrentFlag: LONGINT; VAR outputCurrentFlag: LONGINT): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $1A, $7000, $A82A;
    (*$END*)
PROCEDURE VDSetKeyColor*(ci: VideoDigitizerComponent; index: LONGINT): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $1B, $7000, $A82A;
    (*$END*)
PROCEDURE VDGetKeyColor*(ci: VideoDigitizerComponent; VAR index: LONGINT): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $1C, $7000, $A82A;
    (*$END*)
PROCEDURE VDAddKeyColor*(ci: VideoDigitizerComponent; VAR index: LONGINT): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $1D, $7000, $A82A;
    (*$END*)
PROCEDURE VDGetNextKeyColor*(ci: VideoDigitizerComponent; index: LONGINT): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $1E, $7000, $A82A;
    (*$END*)
PROCEDURE VDSetKeyColorRange*(ci: VideoDigitizerComponent; VAR minRGB: Quickdraw.RGBColor; VAR maxRGB: Quickdraw.RGBColor): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $1F, $7000, $A82A;
    (*$END*)
PROCEDURE VDGetKeyColorRange*(ci: VideoDigitizerComponent; VAR minRGB: Quickdraw.RGBColor; VAR maxRGB: Quickdraw.RGBColor): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $20, $7000, $A82A;
    (*$END*)
PROCEDURE VDSetDigitizerUserInterrupt*(ci: VideoDigitizerComponent; flags: LONGINT; userInterruptProc: VdigIntUPP; refcon: LONGINT): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $21, $7000, $A82A;
    (*$END*)
PROCEDURE VDSetInputColorSpaceMode*(ci: VideoDigitizerComponent; colorSpaceMode: INTEGER): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $2, $22, $7000, $A82A;
    (*$END*)
PROCEDURE VDGetInputColorSpaceMode*(ci: VideoDigitizerComponent; VAR colorSpaceMode: INTEGER): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $23, $7000, $A82A;
    (*$END*)
PROCEDURE VDSetClipState*(ci: VideoDigitizerComponent; clipEnable: INTEGER): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $2, $24, $7000, $A82A;
    (*$END*)
PROCEDURE VDGetClipState*(ci: VideoDigitizerComponent; VAR clipEnable: INTEGER): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $25, $7000, $A82A;
    (*$END*)
PROCEDURE VDSetClipRgn*(ci: VideoDigitizerComponent; clipRegion: Quickdraw.RgnHandle): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $26, $7000, $A82A;
    (*$END*)
PROCEDURE VDClearClipRgn*(ci: VideoDigitizerComponent; clipRegion: Quickdraw.RgnHandle): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $27, $7000, $A82A;
    (*$END*)
PROCEDURE VDGetCLUTInUse*(ci: VideoDigitizerComponent; VAR colorTableHandle: Quickdraw.CTabHandle): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $28, $7000, $A82A;
    (*$END*)
PROCEDURE VDSetPLLFilterType*(ci: VideoDigitizerComponent; pllType: INTEGER): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $2, $29, $7000, $A82A;
    (*$END*)
PROCEDURE VDGetPLLFilterType*(ci: VideoDigitizerComponent; VAR pllType: INTEGER): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $2A, $7000, $A82A;
    (*$END*)
PROCEDURE VDGetMaskandValue*(ci: VideoDigitizerComponent; blendLevel: INTEGER; VAR mask: LONGINT; VAR value: LONGINT): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $A, $2B, $7000, $A82A;
    (*$END*)
PROCEDURE VDSetMasterBlendLevel*(ci: VideoDigitizerComponent; VAR blendLevel: INTEGER): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $2C, $7000, $A82A;
    (*$END*)
PROCEDURE VDSetPlayThruDestination*(ci: VideoDigitizerComponent; dest: Quickdraw.PixMapHandle; VAR destRect: Types.Rect; VAR m: ImageCompression.MatrixRecord; mask: Quickdraw.RgnHandle): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $10, $2D, $7000, $A82A;
    (*$END*)
PROCEDURE VDSetPlayThruOnOff*(ci: VideoDigitizerComponent; state: INTEGER): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $2, $2E, $7000, $A82A;
    (*$END*)
PROCEDURE VDSetFieldPreference*(ci: VideoDigitizerComponent; fieldFlag: INTEGER): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $2, $2F, $7000, $A82A;
    (*$END*)
PROCEDURE VDGetFieldPreference*(ci: VideoDigitizerComponent; VAR fieldFlag: INTEGER): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $30, $7000, $A82A;
    (*$END*)
PROCEDURE VDPreflightDestination*(ci: VideoDigitizerComponent; VAR digitizerRect: Types.Rect; VAR dest: Quickdraw.PixMap; VAR destRect: Types.Rect; VAR m: ImageCompression.MatrixRecord): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $10, $32, $7000, $A82A;
    (*$END*)
PROCEDURE VDPreflightGlobalRect*(ci: VideoDigitizerComponent; theWindow: Quickdraw.GrafPtr; VAR globalRect: Types.Rect): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $33, $7000, $A82A;
    (*$END*)
PROCEDURE VDSetPlayThruGlobalRect*(ci: VideoDigitizerComponent; theWindow: Quickdraw.GrafPtr; VAR globalRect: Types.Rect): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $34, $7000, $A82A;
    (*$END*)
PROCEDURE VDSetInputGammaRecord*(ci: VideoDigitizerComponent; inputGammaPtr: Video.VDGamRecPtr): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $35, $7000, $A82A;
    (*$END*)
PROCEDURE VDGetInputGammaRecord*(ci: VideoDigitizerComponent; VAR inputGammaPtr: Video.VDGamRecPtr): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $36, $7000, $A82A;
    (*$END*)
PROCEDURE VDSetBlackLevelValue*(ci: VideoDigitizerComponent; VAR blackLevel: INTEGER): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $37, $7000, $A82A;
    (*$END*)
PROCEDURE VDGetBlackLevelValue*(ci: VideoDigitizerComponent; VAR blackLevel: INTEGER): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $38, $7000, $A82A;
    (*$END*)
PROCEDURE VDSetWhiteLevelValue*(ci: VideoDigitizerComponent; VAR whiteLevel: INTEGER): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $39, $7000, $A82A;
    (*$END*)
PROCEDURE VDGetWhiteLevelValue*(ci: VideoDigitizerComponent; VAR whiteLevel: INTEGER): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $3A, $7000, $A82A;
    (*$END*)
PROCEDURE VDGetVideoDefaults*(ci: VideoDigitizerComponent; VAR blackLevel: INTEGER; VAR whiteLevel: INTEGER; VAR brightness: INTEGER; VAR hue: INTEGER; VAR saturation: INTEGER; VAR contrast: INTEGER; VAR sharpness: INTEGER): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $1C, $3B, $7000, $A82A;
    (*$END*)
PROCEDURE VDGetNumberOfInputs*(ci: VideoDigitizerComponent; VAR inputs: INTEGER): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $3C, $7000, $A82A;
    (*$END*)
PROCEDURE VDGetInputFormat*(ci: VideoDigitizerComponent; input: INTEGER; VAR format: INTEGER): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $6, $3D, $7000, $A82A;
    (*$END*)
PROCEDURE VDSetInput*(ci: VideoDigitizerComponent; input: INTEGER): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $2, $3E, $7000, $A82A;
    (*$END*)
PROCEDURE VDGetInput*(ci: VideoDigitizerComponent; VAR input: INTEGER): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $3F, $7000, $A82A;
    (*$END*)
PROCEDURE VDSetInputStandard*(ci: VideoDigitizerComponent; inputStandard: INTEGER): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $2, $40, $7000, $A82A;
    (*$END*)
PROCEDURE VDSetupBuffers*(ci: VideoDigitizerComponent; bufferList: VdigBufferRecListHandle): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $41, $7000, $A82A;
    (*$END*)
PROCEDURE VDGrabOneFrameAsync*(ci: VideoDigitizerComponent; buffer: INTEGER): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $2, $42, $7000, $A82A;
    (*$END*)
PROCEDURE VDDone*(ci: VideoDigitizerComponent; buffer: INTEGER): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $2, $43, $7000, $A82A;
    (*$END*)
PROCEDURE VDSetCompression*(ci: VideoDigitizerComponent; compressType: Types.OSType; depth: INTEGER; VAR bounds: Types.Rect; spatialQuality: ImageCompression.CodecQ; temporalQuality: ImageCompression.CodecQ; keyFrameRate: LONGINT): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $16, $44, $7000, $A82A;
    (*$END*)
PROCEDURE VDCompressOneFrameAsync*(ci: VideoDigitizerComponent): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, 0, $45, $7000, $A82A;
    (*$END*)
PROCEDURE VDCompressDone*(ci: VideoDigitizerComponent; VAR done: BOOLEAN; VAR theData: Types.Ptr; VAR dataSize: LONGINT; VAR similarity: Types.UInt8; VAR t: Movies.TimeRecord): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $14, $46, $7000, $A82A;
    (*$END*)
PROCEDURE VDReleaseCompressBuffer*(ci: VideoDigitizerComponent; bufferAddr: Types.Ptr): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $47, $7000, $A82A;
    (*$END*)
PROCEDURE VDGetImageDescription*(ci: VideoDigitizerComponent; desc: ImageCompression.ImageDescriptionHandle): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $48, $7000, $A82A;
    (*$END*)
PROCEDURE VDResetCompressSequence*(ci: VideoDigitizerComponent): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, 0, $49, $7000, $A82A;
    (*$END*)
PROCEDURE VDSetCompressionOnOff*(ci: VideoDigitizerComponent; state: BOOLEAN): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $2, $4A, $7000, $A82A;
    (*$END*)
PROCEDURE VDGetCompressionTypes*(ci: VideoDigitizerComponent; h: VDCompressionListHandle): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $4B, $7000, $A82A;
    (*$END*)
PROCEDURE VDSetTimeBase*(ci: VideoDigitizerComponent; t: Movies.TimeBase): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $4C, $7000, $A82A;
    (*$END*)
PROCEDURE VDSetFrameRate*(ci: VideoDigitizerComponent; framesPerSecond: Types.Fixed): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $4D, $7000, $A82A;
    (*$END*)
PROCEDURE VDGetDataRate*(ci: VideoDigitizerComponent; VAR milliSecPerFrame: LONGINT; VAR framesPerSecond: Types.Fixed; VAR bytesPerSecond: LONGINT): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $4E, $7000, $A82A;
    (*$END*)
PROCEDURE VDGetSoundInputDriver*(ci: VideoDigitizerComponent; VAR soundDriverName: Types.Str255): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $4F, $7000, $A82A;
    (*$END*)
PROCEDURE VDGetDMADepths*(ci: VideoDigitizerComponent; VAR depthArray: LONGINT; VAR preferredDepth: LONGINT): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $50, $7000, $A82A;
    (*$END*)
PROCEDURE VDGetPreferredTimeScale*(ci: VideoDigitizerComponent; VAR preferred: Movies.TimeScale): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $51, $7000, $A82A;
    (*$END*)
PROCEDURE VDReleaseAsyncBuffers*(ci: VideoDigitizerComponent): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, 0, $52, $7000, $A82A;
    (*$END*)
(* 83 is reserved for compatibility reasons *)
PROCEDURE VDSetDataRate*(ci: VideoDigitizerComponent; bytesPerSecond: LONGINT): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $54, $7000, $A82A;
    (*$END*)
PROCEDURE VDGetTimeCode*(ci: VideoDigitizerComponent; VAR atTime: Movies.TimeRecord; timeCodeFormat: (*ΔΔUNIVΔΔ*) Types.Ptr; timeCodeTime: (*ΔΔUNIVΔΔ*) Types.Ptr): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $55, $7000, $A82A;
    (*$END*)
PROCEDURE VDUseSafeBuffers*(ci: VideoDigitizerComponent; useSafeBuffers: BOOLEAN): VideoDigitizerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $2, $56, $7000, $A82A;
    (*$END*)

CONST
    kSelectVDGetMaxSrcRect*        = $1;
    kSelectVDGetActiveSrcRect*    = $2;
    kSelectVDSetDigitizerRect*    = $3;
    kSelectVDGetDigitizerRect*    = $4;
    kSelectVDGetVBlankRect*        = $5;
    kSelectVDGetMaskPixMap*        = $6;
    kSelectVDGetPlayThruDestination* = $8;
    kSelectVDUseThisCLUT*        = $9;
    kSelectVDSetInputGammaValue*    = $A;
    kSelectVDGetInputGammaValue*    = $B;
    kSelectVDSetBrightness*        = $C;
    kSelectVDGetBrightness*        = $D;
    kSelectVDSetContrast*        = $E;
    kSelectVDSetHue*                = $F;
    kSelectVDSetSharpness*        = $10;
    kSelectVDSetSaturation*        = $11;
    kSelectVDGetContrast*        = $12;
    kSelectVDGetHue*                = $13;
    kSelectVDGetSharpness*        = $14;
    kSelectVDGetSaturation*        = $15;
    kSelectVDGrabOneFrame*        = $16;
    kSelectVDGetMaxAuxBuffer*    = $17;
    kSelectVDGetDigitizerInfo*    = $19;
    kSelectVDGetCurrentFlags*    = $1A;
    kSelectVDSetKeyColor*        = $1B;
    kSelectVDGetKeyColor*        = $1C;
    kSelectVDAddKeyColor*        = $1D;
    kSelectVDGetNextKeyColor*    = $1E;
    kSelectVDSetKeyColorRange*    = $1F;
    kSelectVDGetKeyColorRange*    = $20;
    kSelectVDSetDigitizerUserInterrupt* = $21;
    kSelectVDSetInputColorSpaceMode* = $22;
    kSelectVDGetInputColorSpaceMode* = $23;
    kSelectVDSetClipState*        = $24;
    kSelectVDGetClipState*        = $25;
    kSelectVDSetClipRgn*            = $26;
    kSelectVDClearClipRgn*        = $27;
    kSelectVDGetCLUTInUse*        = $28;
    kSelectVDSetPLLFilterType*    = $29;
    kSelectVDGetPLLFilterType*    = $2A;
    kSelectVDGetMaskandValue*    = $2B;
    kSelectVDSetMasterBlendLevel* = $2C;
    kSelectVDSetPlayThruDestination* = $2D;
    kSelectVDSetPlayThruOnOff*    = $2E;
    kSelectVDSetFieldPreference*    = $2F;
    kSelectVDGetFieldPreference*    = $30;
    kSelectVDPreflightDestination* = $32;
    kSelectVDPreflightGlobalRect* = $33;
    kSelectVDSetPlayThruGlobalRect* = $34;
    kSelectVDSetInputGammaRecord* = $35;
    kSelectVDGetInputGammaRecord* = $36;
    kSelectVDSetBlackLevelValue*    = $37;
    kSelectVDGetBlackLevelValue*    = $38;
    kSelectVDSetWhiteLevelValue*    = $39;
    kSelectVDGetWhiteLevelValue*    = $3A;
    kSelectVDGetVideoDefaults*    = $3B;
    kSelectVDGetNumberOfInputs*    = $3C;
    kSelectVDGetInputFormat*        = $3D;
    kSelectVDSetInput*            = $3E;
    kSelectVDGetInput*            = $3F;
    kSelectVDSetInputStandard*    = $40;
    kSelectVDSetupBuffers*        = $41;
    kSelectVDGrabOneFrameAsync*    = $42;
    kSelectVDDone*                = $43;
    kSelectVDSetCompression*        = $44;
    kSelectVDCompressOneFrameAsync* = $45;
    kSelectVDCompressDone*        = $46;
    kSelectVDReleaseCompressBuffer* = $47;
    kSelectVDGetImageDescription* = $48;
    kSelectVDResetCompressSequence* = $49;
    kSelectVDSetCompressionOnOff* = $4A;
    kSelectVDGetCompressionTypes* = $4B;
    kSelectVDSetTimeBase*        = $4C;
    kSelectVDSetFrameRate*        = $4D;
    kSelectVDGetDataRate*        = $4E;
    kSelectVDGetSoundInputDriver* = $4F;
    kSelectVDGetDMADepths*        = $50;
    kSelectVDGetPreferredTimeScale* = $51;
    kSelectVDReleaseAsyncBuffers* = $52;
    kSelectVDSetDataRate*        = $54;
    kSelectVDGetTimeCode*        = $55;
    kSelectVDUseSafeBuffers*        = $56;

    StandardCompressionType*        = LONG("scdi");
    StandardCompressionSubType*    = LONG("imag");

TYPE
    SCModalFilterProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (theDialog: Dialogs.DialogPtr; VAR theEvent: Events.EventRecord; VAR itemHit: INTEGER; refcon: LONGINT): BOOLEAN;
    SCModalHookProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (theDialog: Dialogs.DialogPtr; itemHit: INTEGER; params: (*ΔΔUNIVΔΔ*) Types.Ptr; refcon: LONGINT): INTEGER;
    SCModalFilterUPP* = Types.UniversalProcPtr;
    SCModalHookUPP* = Types.UniversalProcPtr;


CONST
    scListEveryCodec*            = ASH(1,1);
    scAllowZeroFrameRate*        = ASH(1,2);
    scAllowZeroKeyFrameRate*        = ASH(1,3);
    scShowBestDepth*                = ASH(1,4);
    scUseMovableModal*            = ASH(1,5);

(*    Possible test flags for setting test image.*)
    scPreferCropping*            = ASH(1,0);
    scPreferScaling*                = ASH(1,1);
    scPreferScalingAndCropping*    = scPreferScaling + scPreferCropping;

(*    Dimensions of the image preview box.*)
    scTestImageWidth*            = 80;
    scTestImageHeight*            = 80;

(*    Possible items returned by hookProc.*)
    scOKItem*                    = 1;
    scCancelItem*                = 2;
    scCustomItem*                = 3;

(*    Result returned when user cancelled.*)
    scUserCancelled*                = 1;


TYPE
    SCSpatialSettings* = RECORD
        codecType*:                ImageCompression.CodecType;
        codec*:                    ImageCompression.CodecComponent;
        depth*:                    INTEGER;
        spatialQuality*:            ImageCompression.CodecQ;
    END;

    SCTemporalSettings* = RECORD
        temporalQuality*:        ImageCompression.CodecQ;
        frameRate*:                Types.Fixed;
        keyFrameRate*:            LONGINT;
    END;

    SCDataRateSettings* = RECORD
        dataRate*:                LONGINT;
        frameDuration*:            LONGINT;
        minSpatialQuality*:        ImageCompression.CodecQ;
        minTemporalQuality*:        ImageCompression.CodecQ;
    END;

    SCExtendedProcs* = RECORD
        filterProc*:                SCModalFilterUPP;
        hookProc*:                SCModalHookUPP;
        refcon*:                    LONGINT;
        customName*:                Types.Str31;
    END;

(*    Get/SetInfo selectors*)

CONST
    scSpatialSettingsType*        = LONG("sptl");                        (* pointer to SCSpatialSettings struct*)
    scTemporalSettingsType*        = LONG("tprl");                        (* pointer to SCTemporalSettings struct*)
    scDataRateSettingsType*        = LONG("drat");                        (* pointer to SCDataRateSettings struct*)
    scColorTableType*            = LONG("clut");                        (* pointer to Quickdraw.CTabHandle*)
    scProgressProcType*            = LONG("prog");                        (* pointer to ProgressRecord struct*)
    scExtendedProcsType*            = LONG("xprc");                        (* pointer to SCExtendedProcs struct*)
    scPreferenceFlagsType*        = LONG("pref");                        (* pointer to long*)
    scSettingsStateType*            = LONG("ssta");                        (* pointer to Types.Handle*)
    scSequenceIDType*            = LONG("sequ");                        (* pointer to ImageCompression.ImageSequence*)
    scWindowPositionType*        = LONG("wndw");                        (* pointer to Types.Point*)
    scCodecFlagsType*            = LONG("cflg");                        (* pointer to ImageCompression.CodecFlags*)
    scCodecSettingsType*            = LONG("cdec");                        (* pointer to Types.Handle*)
    scForceKeyValueType*            = LONG("ksim");

(*    scTypeNotFoundErr returned by Get/SetInfo when type cannot be found.*)
(** These are Progress procedures **)

PROCEDURE SCPositionRect*(ci: Components.ComponentInstance; VAR rp: Types.Rect; VAR where: Types.Point): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $2, $7000, $A82A;
    (*$END*)
PROCEDURE SCPositionDialog*(ci: Components.ComponentInstance; id: INTEGER; VAR where: Types.Point): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $6, $3, $7000, $A82A;
    (*$END*)
PROCEDURE SCSetTestImagePictHandle*(ci: Components.ComponentInstance; testPict: Quickdraw.PicHandle; VAR testRect: Types.Rect; testFlags: INTEGER): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $A, $4, $7000, $A82A;
    (*$END*)
PROCEDURE SCSetTestImagePictFile*(ci: Components.ComponentInstance; testFileRef: INTEGER; VAR testRect: Types.Rect; testFlags: INTEGER): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $5, $7000, $A82A;
    (*$END*)
PROCEDURE SCSetTestImagePixMap*(ci: Components.ComponentInstance; testPixMap: Quickdraw.PixMapHandle; VAR testRect: Types.Rect; testFlags: INTEGER): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $A, $6, $7000, $A82A;
    (*$END*)
PROCEDURE SCGetBestDeviceRect*(ci: Components.ComponentInstance; VAR r: Types.Rect): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $7, $7000, $A82A;
    (*$END*)
PROCEDURE SCRequestImageSettings*(ci: Components.ComponentInstance): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, 0, $A, $7000, $A82A;
    (*$END*)
PROCEDURE SCCompressImage*(ci: Components.ComponentInstance; src: Quickdraw.PixMapHandle; (*CONST*)VAR srcRect: Types.Rect; VAR desc: ImageCompression.ImageDescriptionHandle; VAR data: Types.Handle): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $10, $B, $7000, $A82A;
    (*$END*)
PROCEDURE SCCompressPicture*(ci: Components.ComponentInstance; srcPicture: Quickdraw.PicHandle; dstPicture: Quickdraw.PicHandle): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $C, $7000, $A82A;
    (*$END*)
PROCEDURE SCCompressPictureFile*(ci: Components.ComponentInstance; srcRefNum: INTEGER; dstRefNum: INTEGER): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $D, $7000, $A82A;
    (*$END*)
PROCEDURE SCRequestSequenceSettings*(ci: Components.ComponentInstance): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, 0, $E, $7000, $A82A;
    (*$END*)
PROCEDURE SCCompressSequenceBegin*(ci: Components.ComponentInstance; src: Quickdraw.PixMapHandle; (*CONST*)VAR srcRect: Types.Rect; VAR desc: ImageCompression.ImageDescriptionHandle): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $F, $7000, $A82A;
    (*$END*)
PROCEDURE SCCompressSequenceFrame*(ci: Components.ComponentInstance; src: Quickdraw.PixMapHandle; (*CONST*)VAR srcRect: Types.Rect; VAR data: Types.Handle; VAR dataSize: LONGINT; VAR notSyncFlag: INTEGER): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $14, $10, $7000, $A82A;
    (*$END*)
PROCEDURE SCCompressSequenceEnd*(ci: Components.ComponentInstance): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, 0, $11, $7000, $A82A;
    (*$END*)
PROCEDURE SCDefaultPictHandleSettings*(ci: Components.ComponentInstance; srcPicture: Quickdraw.PicHandle; motion: INTEGER): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $6, $12, $7000, $A82A;
    (*$END*)
PROCEDURE SCDefaultPictFileSettings*(ci: Components.ComponentInstance; srcRef: INTEGER; motion: INTEGER): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $13, $7000, $A82A;
    (*$END*)
PROCEDURE SCDefaultPixMapSettings*(ci: Components.ComponentInstance; src: Quickdraw.PixMapHandle; motion: INTEGER): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $6, $14, $7000, $A82A;
    (*$END*)
PROCEDURE SCGetInfo*(ci: Components.ComponentInstance; infoType: Types.OSType; info: (*ΔΔUNIVΔΔ*) Types.Ptr): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $15, $7000, $A82A;
    (*$END*)
PROCEDURE SCSetInfo*(ci: Components.ComponentInstance; infoType: Types.OSType; info: (*ΔΔUNIVΔΔ*) Types.Ptr): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $16, $7000, $A82A;
    (*$END*)
PROCEDURE SCNewGWorld*(ci: Components.ComponentInstance; VAR gwp: QDOffscreen.GWorldPtr; VAR rp: Types.Rect; flags: QDOffscreen.GWorldFlags): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $17, $7000, $A82A;
    (*$END*)
PROCEDURE SCSetCompressFlags*(ci: Components.ComponentInstance; flags: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $18, $7000, $A82A;
    (*$END*)
PROCEDURE SCGetCompressFlags*(ci: Components.ComponentInstance; VAR flags: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $19, $7000, $A82A;
    (*$END*)

TYPE
    SCParams* = RECORD
        flags*:                    LONGINT;
        theCodecType*:            ImageCompression.CodecType;
        theCodec*:                ImageCompression.CodecComponent;
        spatialQuality*:            ImageCompression.CodecQ;
        temporalQuality*:        ImageCompression.CodecQ;
        depth*:                    INTEGER;
        frameRate*:                Types.Fixed;
        keyFrameRate*:            LONGINT;
        reserved1*:                LONGINT;
        reserved2*:                LONGINT;
    END;


CONST
    scGetCompression*            = 1;
    scShowMotionSettings*        = ASH(1,0);
    scSettingsChangedItem*        = -1;

    scCompressFlagIgnoreIdenticalFrames* = 1;


PROCEDURE SCGetCompressionExtended*(ci: Components.ComponentInstance; VAR params: SCParams; where: Types.Point; filterProc: SCModalFilterUPP; hookProc: SCModalHookUPP; refcon: LONGINT; customName: Types.StringPtr): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $18, $1, $7000, $A82A;
    (*$END*)

CONST
    kSCPositionRectSelect*        = $2;
    kSCPositionDialogSelect*        = $3;
    kSCSetTestImagePictHandleSelect* = $4;
    kSCSetTestImagePictFileSelect* = $5;
    kSCSetTestImagePixMapSelect*    = $6;
    kSCGetBestDeviceRectSelect*    = $7;
    kSCRequestImageSettingsSelect* = $A;
    kSCCompressImageSelect*        = $B;
    kSCCompressPictureSelect*    = $C;
    kSCCompressPictureFileSelect* = $D;
    kSCRequestSequenceSettingsSelect* = $E;
    kSCCompressSequenceBeginSelect* = $F;
    kSCCompressSequenceFrameSelect* = $10;
    kSCCompressSequenceEndSelect* = $11;
    kSCDefaultPictHandleSettingsSelect* = $12;
    kSCDefaultPictFileSettingsSelect* = $13;
    kSCDefaultPixMapSettingsSelect* = $14;
    kSCGetInfoSelect*            = $15;
    kSCSetInfoSelect*            = $16;
    kSCNewGWorldSelect*            = $17;
    kSCSetCompressFlagsSelect*    = $18;
    kSCGetCompressFlagsSelect*    = $19;
    kSCGetCompressionExtendedSelect* = $1;


TYPE
    MovieImportComponent* = Components.ComponentInstance;
    MovieExportComponent* = Components.ComponentInstance;


CONST
    MovieImportType*                = LONG("eat ");
    MovieExportType*                = LONG("spit");

    canMovieImportHandles*        = ASH(1,0);
    canMovieImportFiles*            = ASH(1,1);
    hasMovieImportUserInterface*    = ASH(1,2);
    canMovieExportHandles*        = ASH(1,3);
    canMovieExportFiles*            = ASH(1,4);
    hasMovieExportUserInterface*    = ASH(1,5);
    dontAutoFileMovieImport*        = ASH(1,6);
    canMovieExportAuxDataHandle*    = ASH(1,7);
    canMovieImportValidateHandles* = ASH(1,8);
    canMovieImportValidateFile*    = ASH(1,9);
    dontRegisterWithEasyOpen*    = ASH(1,10);
    canMovieImportInPlace*        = ASH(1,11);
    movieImportSubTypeIsFileExtension* = ASH(1,12);

    kMovieImportExportOpenSelect* = Components.kComponentOpenSelect;
    kMovieImportExportCloseSelect* = Components.kComponentCloseSelect;
    kMovieImportExportCanDoSelect* = Components.kComponentCanDoSelect;
    kMovieImportExportVersionSelect* = Components.kComponentVersionSelect;
    kMovieImportHandleSelect*    = 1;
    kMovieImportFileSelect*        = 2;
    kMovieImportSetSampleDurationSelect* = 3;
    kMovieImportSetSampleDescriptionSelect* = 4;
    kMovieImportSetMediaFileSelect* = 5;
    kMovieImportSetDimensionsSelect* = 6;
    kMovieImportSetChunkSizeSelect* = 7;
    kMovieImportSetProgressProcSelect* = 8;
    kMovieImportSetAuxiliaryDataSelect* = 9;
    kMovieImportSetFromScrapSelect* = 10;
    kMovieImportDoUserDialogSelect* = 11;
    kMovieImportSetDurationSelect* = 12;
    kMovieImportGetAuxiliaryDataTypeSelect* = 13;
    kMovieImportValidateSelect*    = 14;
    kMovieImportGetFileTypeSelect* = 15;
    kMovieExportToHandleSelect*    = 128;
    kMovieExportToFileSelect*    = 129;
    kMovieExportDoUserDialogSelectOBSOLETE* = 130;
    kMovieExportGetAuxiliaryDataSelect* = 131;
    kMovieExportSetProgressProcSelect* = 132;
    kMovieExportSetSampleDescriptionSelect* = 133;
    kMovieExportDoUserDialogSelect* = 134;
    kMovieExportGetCreatorTypeSelect* = 135;

    movieImportCreateTrack*        = 1;
    movieImportInParallel*        = 2;
    movieImportMustUseTrack*        = 4;

    movieImportResultUsedMultipleTracks* = 8;


PROCEDURE MovieImportHandle*(ci: MovieImportComponent; dataH: Types.Handle; theMovie: Movies.Movie; targetTrack: Movies.Track; VAR usedTrack: Movies.Track; atTime: Movies.TimeValue; VAR addedDuration: Movies.TimeValue; inFlags: LONGINT; VAR outFlags: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $20, $1, $7000, $A82A;
    (*$END*)
PROCEDURE MovieImportFile*(ci: MovieImportComponent; (*CONST*)VAR theFile: Files.FSSpec; theMovie: Movies.Movie; targetTrack: Movies.Track; VAR usedTrack: Movies.Track; atTime: Movies.TimeValue; VAR addedDuration: Movies.TimeValue; inFlags: LONGINT; VAR outFlags: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $20, $2, $7000, $A82A;
    (*$END*)
PROCEDURE MovieImportSetSampleDuration*(ci: MovieImportComponent; duration: Movies.TimeValue; scale: Movies.TimeScale): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $3, $7000, $A82A;
    (*$END*)
PROCEDURE MovieImportSetSampleDescription*(ci: MovieImportComponent; desc: Movies.SampleDescriptionHandle; mediaType: Types.OSType): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $4, $7000, $A82A;
    (*$END*)
PROCEDURE MovieImportSetMediaFile*(ci: MovieImportComponent; alias: Aliases.AliasHandle): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $5, $7000, $A82A;
    (*$END*)
PROCEDURE MovieImportSetDimensions*(ci: MovieImportComponent; width: Types.Fixed; height: Types.Fixed): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $6, $7000, $A82A;
    (*$END*)
PROCEDURE MovieImportSetChunkSize*(ci: MovieImportComponent; chunkSize: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $7, $7000, $A82A;
    (*$END*)
PROCEDURE MovieImportSetProgressProc*(ci: MovieImportComponent; proc: Movies.MovieProgressUPP; refcon: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $8, $7000, $A82A;
    (*$END*)
PROCEDURE MovieImportSetAuxiliaryData*(ci: MovieImportComponent; data: Types.Handle; handleType: Types.OSType): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $9, $7000, $A82A;
    (*$END*)
PROCEDURE MovieImportSetFromScrap*(ci: MovieImportComponent; fromScrap: BOOLEAN): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $2, $A, $7000, $A82A;
    (*$END*)
PROCEDURE MovieImportDoUserDialog*(ci: MovieImportComponent; (*CONST*)VAR theFile: Files.FSSpec; theData: Types.Handle; VAR canceled: BOOLEAN): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $B, $7000, $A82A;
    (*$END*)
PROCEDURE MovieImportSetDuration*(ci: MovieImportComponent; duration: Movies.TimeValue): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $C, $7000, $A82A;
    (*$END*)
PROCEDURE MovieImportGetAuxiliaryDataType*(ci: MovieImportComponent; VAR auxType: Types.OSType): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $D, $7000, $A82A;
    (*$END*)
PROCEDURE MovieImportValidate*(ci: MovieImportComponent; (*CONST*)VAR theFile: Files.FSSpec; theData: Types.Handle; VAR valid: BOOLEAN): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $E, $7000, $A82A;
    (*$END*)
PROCEDURE MovieImportGetFileType*(ci: MovieImportComponent; VAR fileType: Types.OSType): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $F, $7000, $A82A;
    (*$END*)
PROCEDURE MovieExportToHandle*(ci: MovieExportComponent; dataH: Types.Handle; theMovie: Movies.Movie; onlyThisTrack: Movies.Track; startTime: Movies.TimeValue; duration: Movies.TimeValue): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $14, $80, $7000, $A82A;
    (*$END*)
PROCEDURE MovieExportToFile*(ci: MovieExportComponent; (*CONST*)VAR theFile: Files.FSSpec; theMovie: Movies.Movie; onlyThisTrack: Movies.Track; startTime: Movies.TimeValue; duration: Movies.TimeValue): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $14, $81, $7000, $A82A;
    (*$END*)
PROCEDURE MovieExportGetAuxiliaryData*(ci: MovieExportComponent; dataH: Types.Handle; VAR handleType: Types.OSType): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $83, $7000, $A82A;
    (*$END*)
PROCEDURE MovieExportSetProgressProc*(ci: MovieExportComponent; proc: Movies.MovieProgressUPP; refcon: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $84, $7000, $A82A;
    (*$END*)
PROCEDURE MovieExportSetSampleDescription*(ci: MovieExportComponent; desc: Movies.SampleDescriptionHandle; mediaType: Types.OSType): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $85, $7000, $A82A;
    (*$END*)
PROCEDURE MovieExportDoUserDialog*(ci: MovieExportComponent; theMovie: Movies.Movie; onlyThisTrack: Movies.Track; startTime: Movies.TimeValue; duration: Movies.TimeValue; VAR canceled: BOOLEAN): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $14, $86, $7000, $A82A;
    (*$END*)
PROCEDURE MovieExportGetCreatorType*(ci: MovieExportComponent; VAR creator: Types.OSType): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $87, $7000, $A82A;
    (*$END*)
(* Text Export Display Info data structure*)

TYPE
    TextDisplayData* = RECORD
        displayFlags*:            LONGINT;
        textJustification*:        LONGINT;
        bgColor*:                Quickdraw.RGBColor;
        textBox*:                Types.Rect;
        beginHilite*:            INTEGER;
        endHilite*:                INTEGER;
        hiliteColor*:            Quickdraw.RGBColor;
        doHiliteColor*:            BOOLEAN;
        filler*:                    Types.SInt8;
        scrollDelayDur*:            Movies.TimeValue;
        dropShadowOffset*:        Types.Point;
        dropShadowTransparency*:    INTEGER;
    END;

    TextExportComponent* = Components.ComponentInstance;


PROCEDURE TextExportGetDisplayData*(ci: TextExportComponent; VAR textDisplay: TextDisplayData): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $100, $7000, $A82A;
    (*$END*)
(***************

    File Preview Components

***************)

TYPE
    pnotComponent* = Components.ComponentInstance;


CONST
    pnotComponentWantsEvents*    = 1;
    pnotComponentNeedsNoCache*    = 2;

    kPreviewOpenSelector*        = 0;
    kPreviewCloseSelector*        = -1;
    kPreviewCanDoSelector*        = -2;
    kPreviewVersionSelector*        = -3;
    kPreviewShowDataSelector*    = 1;
    kPreviewMakePreviewSelector*    = 2;
    kPreviewMakePreviewReferenceSelector* = 3;
    kPreviewEventSelector*        = 4;

    ShowFilePreviewComponentType* = LONG("pnot");
    CreateFilePreviewComponentType* = LONG("pmak");


PROCEDURE PreviewShowData*(p: pnotComponent; dataType: Types.OSType; data: Types.Handle; (*CONST*)VAR inHere: Types.Rect): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $1, $7000, $A82A;
    (*$END*)
PROCEDURE PreviewMakePreview*(p: pnotComponent; VAR previewType: Types.OSType; VAR previewResult: Types.Handle; (*CONST*)VAR sourceFile: Files.FSSpec; progress: ImageCompression.ICMProgressProcRecordPtr): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $10, $2, $7000, $A82A;
    (*$END*)
PROCEDURE PreviewMakePreviewReference*(p: pnotComponent; VAR previewType: Types.OSType; VAR resID: INTEGER; (*CONST*)VAR sourceFile: Files.FSSpec): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $3, $7000, $A82A;
    (*$END*)
PROCEDURE PreviewEvent*(p: pnotComponent; VAR e: Events.EventRecord; VAR handledEvent: BOOLEAN): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $4, $7000, $A82A;
    (*$END*)
TYPE
    DataHCompletionProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (request: Types.Ptr; refcon: LONGINT; err: Types.OSErr);
    DataHCompletionUPP* = Types.UniversalProcPtr;


CONST
    kDataHCanRead*                = ASH(1,0);
    kDataHSpecialRead*            = ASH(1,1);
    kDataHSpecialReadFile*        = ASH(1,2);
    kDataHCanWrite*                = ASH(1,3);
    kDataHSpecialWrite*            = ASH(1,4);
    kDataHSpecialWriteFile*        = ASH(1,5);
    kDataHCanStreamingWrite*        = ASH(1,6);
    kDataHMustCheckDataRef*        = ASH(1,7);


TYPE
    DataHVolumeListRecord* = RECORD
        vRefNum*:                INTEGER;
        flags*:                    LONGINT;
    END;

    DataHVolumeListPtr* = POINTER TO DataHVolumeListRecord;

    DataHVolumeList* = HANDLE TO DataHVolumeListRecord (*ΔΔ POINTER TO DataHVolumeListPtr*);


CONST
    kDataHExtendedSchedule*        = LONG("xtnd");


TYPE
    DataHScheduleRecord* = RECORD
        timeNeededBy*:            Movies.TimeRecord;
        extendedID*:                LONGINT;                                (* always is kDataHExtendedSchedule*)
        extendedVers*:            LONGINT;                                (* always set to 0*)
        priority*:                Types.Fixed;                                    (* 100.0 or more means must have. lower numbers…*)
    END;

    DataHSchedulePtr* = POINTER TO DataHScheduleRecord;


PROCEDURE DataHGetData*(dh: Movies.DataHandler; h: Types.Handle; hOffset: LONGINT; offset: LONGINT; size: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $10, $2, $7000, $A82A;
    (*$END*)
PROCEDURE DataHPutData*(dh: Movies.DataHandler; h: Types.Handle; hOffset: LONGINT; VAR offset: LONGINT; size: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $10, $3, $7000, $A82A;
    (*$END*)
PROCEDURE DataHFlushData*(dh: Movies.DataHandler): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, 0, $4, $7000, $A82A;
    (*$END*)
PROCEDURE DataHOpenForWrite*(dh: Movies.DataHandler): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, 0, $5, $7000, $A82A;
    (*$END*)
PROCEDURE DataHCloseForWrite*(dh: Movies.DataHandler): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, 0, $6, $7000, $A82A;
    (*$END*)
PROCEDURE DataHOpenForRead*(dh: Movies.DataHandler): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, 0, $8, $7000, $A82A;
    (*$END*)
PROCEDURE DataHCloseForRead*(dh: Movies.DataHandler): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, 0, $9, $7000, $A82A;
    (*$END*)
PROCEDURE DataHSetDataRef*(dh: Movies.DataHandler; dataRef: Types.Handle): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $A, $7000, $A82A;
    (*$END*)
PROCEDURE DataHGetDataRef*(dh: Movies.DataHandler; VAR dataRef: Types.Handle): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $B, $7000, $A82A;
    (*$END*)
PROCEDURE DataHCompareDataRef*(dh: Movies.DataHandler; dataRef: Types.Handle; VAR equal: BOOLEAN): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $C, $7000, $A82A;
    (*$END*)
PROCEDURE DataHTask*(dh: Movies.DataHandler): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, 0, $D, $7000, $A82A;
    (*$END*)
PROCEDURE DataHScheduleData*(dh: Movies.DataHandler; PlaceToPutDataPtr: Types.Ptr; FileOffset: LONGINT; DataSize: LONGINT; RefCon: LONGINT; scheduleRec: DataHSchedulePtr; CompletionRtn: DataHCompletionUPP): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $18, $E, $7000, $A82A;
    (*$END*)
PROCEDURE DataHFinishData*(dh: Movies.DataHandler; PlaceToPutDataPtr: Types.Ptr; Cancel: BOOLEAN): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $6, $F, $7000, $A82A;
    (*$END*)
PROCEDURE DataHFlushCache*(dh: Movies.DataHandler): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, 0, $10, $7000, $A82A;
    (*$END*)
PROCEDURE DataHResolveDataRef*(dh: Movies.DataHandler; theDataRef: Types.Handle; VAR wasChanged: BOOLEAN; userInterfaceAllowed: BOOLEAN): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $A, $11, $7000, $A82A;
    (*$END*)
PROCEDURE DataHGetFileSize*(dh: Movies.DataHandler; VAR fileSize: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $12, $7000, $A82A;
    (*$END*)
PROCEDURE DataHCanUseDataRef*(dh: Movies.DataHandler; dataRef: Types.Handle; VAR useFlags: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $13, $7000, $A82A;
    (*$END*)
PROCEDURE DataHGetVolumeList*(dh: Movies.DataHandler; VAR volumeList: DataHVolumeList): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $14, $7000, $A82A;
    (*$END*)
PROCEDURE DataHWrite*(dh: Movies.DataHandler; data: Types.Ptr; offset: LONGINT; size: LONGINT; completion: DataHCompletionUPP; refCon: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $14, $15, $7000, $A82A;
    (*$END*)
PROCEDURE DataHPreextend*(dh: Movies.DataHandler; maxToAdd: LONGINT; VAR spaceAdded: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $16, $7000, $A82A;
    (*$END*)
PROCEDURE DataHSetFileSize*(dh: Movies.DataHandler; fileSize: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $17, $7000, $A82A;
    (*$END*)
PROCEDURE DataHGetFreeSpace*(dh: Movies.DataHandler; VAR freeSize: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $18, $7000, $A82A;
    (*$END*)
PROCEDURE DataHCreateFile*(dh: Movies.DataHandler; creator: Types.OSType; deleteExisting: BOOLEAN): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $6, $19, $7000, $A82A;
    (*$END*)
PROCEDURE DataHGetPreferredBlockSize*(dh: Movies.DataHandler; VAR blockSize: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $1A, $7000, $A82A;
    (*$END*)
PROCEDURE DataHGetDeviceIndex*(dh: Movies.DataHandler; VAR deviceIndex: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $1B, $7000, $A82A;
    (*$END*)
PROCEDURE DataHIsStreamingDataHandler*(dh: Movies.DataHandler; VAR yes: BOOLEAN): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $1C, $7000, $A82A;
    (*$END*)
PROCEDURE DataHGetDataInBuffer*(dh: Movies.DataHandler; startOffset: LONGINT; VAR size: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $1D, $7000, $A82A;
    (*$END*)
PROCEDURE DataHGetScheduleAheadTime*(dh: Movies.DataHandler; VAR millisecs: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $1E, $7000, $A82A;
    (*$END*)
PROCEDURE DataHSetCacheSizeLimit*(dh: Movies.DataHandler; cacheSizeLimit: Memory.Size): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $1F, $7000, $A82A;
    (*$END*)
PROCEDURE DataHGetCacheSizeLimit*(dh: Movies.DataHandler; VAR cacheSizeLimit: Memory.Size): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $20, $7000, $A82A;
    (*$END*)
PROCEDURE DataHPlaybackHints*(dh: Movies.DataHandler; flags: LONGINT; minFileOffset: LONGINT; maxFileOffset: LONGINT; bytesPerSecond: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $10, $103, $7000, $A82A;
    (*$END*)

CONST
    kDataHGetDataSelect*            = $2;
    kDataHPutDataSelect*            = $3;
    kDataHFlushDataSelect*        = $4;
    kDataHOpenForWriteSelect*    = $5;
    kDataHCloseForWriteSelect*    = $6;
    kDataHOpenForReadSelect*        = $8;
    kDataHCloseForReadSelect*    = $9;
    kDataHSetDataRefSelect*        = $A;
    kDataHGetDataRefSelect*        = $B;
    kDataHCompareDataRefSelect*    = $C;
    kDataHTaskSelect*            = $D;
    kDataHScheduleDataSelect*    = $E;
    kDataHFinishDataSelect*        = $F;
    kDataHFlushCacheSelect*        = $10;
    kDataHResolveDataRefSelect*    = $11;
    kDataHGetFileSizeSelect*        = $12;
    kDataHCanUseDataRefSelect*    = $13;
    kDataHGetVolumeListSelect*    = $14;
    kDataHWriteSelect*            = $15;
    kDataHPreextendSelect*        = $16;
    kDataHSetFileSizeSelect*        = $17;
    kDataHGetFreeSpaceSelect*    = $18;
    kDataHCreateFileSelect*        = $19;
    kDataHGetPreferredBlockSizeSelect* = $1A;
    kDataHGetDeviceIndexSelect*    = $1B;
    kDataHIsStreamingDataHandlerSelect* = $1C;
    kDataHGetDataInBufferSelect*    = $1D;
    kDataHGetScheduleAheadTimeSelect* = $1E;
    kDataHSetCacheSizeLimitSelect* = $1F;
    kDataHGetCacheSizeLimitSelect* = $20;
    kDataHPlaybackHintsSelect*    = $103;

    kMusicComponentType*            = LONG("musi");


TYPE
    MusicComponent* = Components.ComponentInstance;

(* MusicSynthesizerFlags*)

CONST
    kSynthesizerDynamicVoice*    = 1;                            (* can reassign voices/channels (else, hogs all channels in mask *)
    kSynthesizerUsesMIDIPort*    = 2;                            (* must be patched through MIDI Manager *)
    kSynthesizerMicrotone*        = 4;                            (* can play microtonal scales *)
    kSynthesizerLimitedMicrotone* = 8;                            (* can play microtones, but only on 1-voice parts *)
    kSynthesizerMixedDrums*        = 16;                            (* any part can play drum parts, total* = instrument parts *)
    kSynthesizerSoftware*        = 32;                            (* implemented in main CPU software == uses cpu cycles *)
    kSynthesizerGMSuperset*        = 8192;
    kSynthesizerGM*                = 16384;                        (* synth is a GM device *)

(*
 * Note that these controller numbers
 * are _not_ identical to the MIDI controller numbers.
 * These are _signed_ 8.8 values, and the LSB's are
 * always sent to a MIDI device. Controllers 32-63 are
 * reserved (for MIDI, they are LSB's for 0-31, but we
 * always send both).
 *
 * The full range, therefore, is -128.00 to 127.7f.
 *
 * _Excepting_ _volume_, all controls default to zero.
 *
 * Pitch bend is specified in fractional semitones! No
 * more "pitch bend range" nonsense. You can bend as far
 * as you want, any time you want.
 *)
    kControllerModulationWheel*    = 1;
    kControllerBreath*            = 2;
    kControllerFoot*                = 4;
    kControllerPortamentoTime*    = 5;
    kControllerVolume*            = 7;
    kControllerBalance*            = 8;
    kControllerPan*                = 10;                            (* 0 - "default", 1 - n: positioned in output 1-n (incl fractions) *)
    kControllerExpression*        = 11;
    kControllerPitchBend*        = 32;                            (* positive & negative semitones, with 7 bits fraction *)
    kControllerAfterTouch*        = 33;
    kControllerSustain*            = 64;                            (* boolean - positive for on, 0 or negative off *)
    kControllerPortamento*        = 65;                            (* boolean *)
    kControllerSostenuto*        = 66;                            (* boolean *)
    kControllerSoftPedal*        = 67;                            (* boolean *)
    kControllerReverb*            = 91;
    kControllerTremolo*            = 92;
    kControllerChorus*            = 93;
    kControllerCeleste*            = 94;
    kControllerPhaser*            = 95;

    kControllerMaximum*            = $7FFF;                        (* +01111111.11111111 *)
    kControllerMinimum*            = $8000;                        (* -10000000.00000000 *)


TYPE
    SynthesizerDescription* = RECORD
        synthesizerType*:        Types.OSType;                                    (* synthesizer type (must be same as component subtype) *)
        name*:                    Types.Str31;                                    (* text name of synthesizer type *)
        flags*:                    LONGINT;                                (* from the above enum *)
        voiceCount*:                LONGINT;                                (* maximum polyphony *)
        partCount*:                LONGINT;                                (* maximum multi-timbrality (and midi channels) *)
        instrumentCount*:        LONGINT;                                (* non gm, built in (rom) instruments only *)
        modifiableInstrumentCount*: LONGINT;                                (* plus n-more are user modifiable *)
        channelMask*:            LONGINT;                                (* (midi device only) which channels device always uses *)
        drumPartCount*:            LONGINT;                                (* maximum multi-timbrality of drum parts *)
        drumCount*:                LONGINT;                                (* non gm, built in (rom) drumkits only *)
        modifiableDrumCount*:    LONGINT;                                (* plus n-more are user modifiable *)
        drumChannelMask*:        LONGINT;                                (* (midi device only) which channels device always uses *)
        outputCount*:            LONGINT;                                (* number of audio outputs (usually two) *)
        latency*:                LONGINT;                                (* response time in µSec *)
        controllers*:            ARRAY 4 (*ΔΔ[0..3]ΔΔ*) OF LONGINT;                (* array of 128 bits *)
        gmInstruments*:            ARRAY 4 (*ΔΔ[0..3]ΔΔ*) OF LONGINT;                (* array of 128 bits *)
        gmDrums*:                ARRAY 4 (*ΔΔ[0..3]ΔΔ*) OF LONGINT;                (* array of 128 bits *)
    END;


CONST
    kVoiceCountDynamic*            = -1;                            (* constant to use to specify dynamic voicing *)


TYPE
    ToneDescription* = RECORD
        synthesizerType*:        Types.OSType;                                    (* synthesizer type *)
        synthesizerName*:        Types.Str31;                                    (* name of instantiation of synth *)
        instrumentName*:            Types.Str31;                                    (* preferred name for human use *)
        instrumentNumber*:        LONGINT;                                (* inst-number used if synth-name matches *)
        gmNumber*:                LONGINT;                                (* Best matching general MIDI number *)
    END;


CONST
    kFirstDrumkit*                = 16384;                        (* (first value is "no drum". instrument numbers from 16384->16384+128 are drumkits, and for GM they are _defined_ drumkits! *)
    kLastDrumkit*                = kFirstDrumkit + 128;

(* InstrumentMatch*)
    kInstrumentMatchSynthesizerType* = 1;
    kInstrumentMatchSynthesizerName* = 2;
    kInstrumentMatchName*        = 4;
    kInstrumentMatchNumber*        = 8;
    kInstrumentMatchGMNumber*    = 16;

(* KnobFlags*)
    kKnobRealtime*                = 1;                            (* Knob can be changed interactively as part of a sequence (ie knob can be changed at interrupt time) *)
    kKnobNextNote*                = 2;                            (* Knob only takes effect on the next note played *)
    kKnobAction*                    = 4;                            (* setting the knob does something immediate *)
    kKnobNotInstrument*            = 8;                            (* indicates that the knob isn't in the instrument handle *)
    kKnobAffectsOthers*            = 16;                            (* other knobs will change value from this one *)
    kKnobMinorGroupStart*        = 64;                            (* knob is first in some logical subgroup of knobs *)
    kKnobGroupStart*                = 128;                            (* knob is first in some logical group of knobs *)
(* One of these may be used at a time. *)
    kKnobTypeNumber*                = 0 * (ASH(1,12));
    kKnobTypeBoolean*            = ASH(1,12);
    kKnobTypeNote*                = 2 * (ASH(1,12));
    kKnobTypePan*                = 3 * (ASH(1,12));
    kKnobTypeInstrument*            = 4 * (ASH(1,12));                (* knob value* = reference to another instrument number *)
    kKnobTypeSetting*            = 5 * (ASH(1,12));                (* knob value is 1 of n different things (eg, fm algorithms) *)

    kUnknownKnobValue*            = $7FFFFFFF;                    (* a knob with this value means, we don't know it. *)


TYPE
    KnobDescription* = RECORD
        name*:                    Types.Str31;
        lowValue*:                LONGINT;
        highValue*:                LONGINT;
        defaultValue*:            LONGINT;                                (* a default instrument is made of all default values *)
        flags*:                    LONGINT;
    END;

    InstrumentData* = RECORD
        tone*:                    ToneDescription;
        knobCount*:                LONGINT;
        knob*:                    ARRAY 1 (*ΔΔ[0..0]ΔΔ*) OF LONGINT;
    END;

    InstrumentDataPtr* = POINTER TO InstrumentData;
    InstrumentDataHandle* = HANDLE TO InstrumentData (*ΔΔ POINTER TO InstrumentDataPtr*);

    FlatInstrument* = RECORD
        tone*:                    ToneDescription;
        size*:                    LONGINT;                                (* size in bytes of the following data, including size field (excluding tonedescription) *)
        data*:                    (*ΔΔPACKEDΔΔ*) ARRAY 4 (*ΔΔ[0..3]ΔΔ*) OF Types.SInt8; (* UInt8 *)
    END;

    InstrumentAboutInfo* = RECORD
        p*:                        Quickdraw.PicHandle;
        author*:                    Types.Str255;
        copyright*:                Types.Str255;
        other*:                    Types.Str255;
    END;

    MusicMIDIPacket* = RECORD
        length*:                    INTEGER;
        reserved*:                LONGINT;
        data*:                    (*ΔΔPACKEDΔΔ*) ARRAY 249 (*ΔΔ[0..248]ΔΔ*) OF Types.SInt8; (* UInt8 *)
    END;

    MusicMIDISendProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (self: MusicComponent; refCon: LONGINT; VAR mmp: MusicMIDIPacket): Components.ComponentResult;
    MusicMIDISendUPP* = Types.UniversalProcPtr;


CONST
    kMusicFirstSelect*            = 0;
    kMusicGetDescriptionSelect*    = 1;
    kMusicGetPartSelect*            = 2;
    kMusicSetPartSelect*            = 3;
    kMusicSetInstrumentNumberSelect* = 4;
    kMusicGetInstrumentNumberSelect* = 5;
    kMusicStoreInstrumentSelect*    = 6;
    kMusicGetInstrumentSelect*    = 7;
    kMusicSetInstrumentSelect*    = 8;
    kMusicDummyOne*                = 9;
    kMusicDummyTwo*                = 10;
    kMusicDummyThree*            = 11;
    kMusicDummyFour*                = 12;
    kMusicGetInstrumentKnobDescriptionSelect* = 13;
    kMusicGetDrumKnobDescriptionSelect* = 14;
    kMusicGetKnobDescriptionSelect* = 15;
    kMusicGetPartKnobSelect*        = 16;
    kMusicSetPartKnobSelect*        = 17;
    kMusicGetKnobSelect*            = 18;
    kMusicSetKnobSelect*            = 19;
    kMusicGetPartNameSelect*        = 20;
    kMusicSetPartNameSelect*        = 21;
    kMusicFindToneSelect*        = 22;
    kMusicPlayNoteSelect*        = 23;
    kMusicResetPartSelect*        = 24;
    kMusicSetControllerSelect*    = 25;
    kMusicGetControllerSelect*    = 26;
    kMusicGetMIDIProcSelect*        = 27;
    kMusicSetMIDIProcSelect*        = 28;
    kMusicGetInstrumentNamesSelect* = 29;
    kMusicGetDrumNamesSelect*    = 30;
    kMusicGetMasterTuneSelect*    = 31;
    kMusicSetMasterTuneSelect*    = 32;
    kMusicSetFlatInstrumentSelect* = 33;
    kMusicGetInstrumentAboutInfoSelect* = 34;

    notImplementedMusicErr*        = $80000000 + ((-2100 - 1));
    cantSendToSynthesizerErr*    = $80000000 + ((-2100 - 2));
    cantReceiveFromSynthesizerErr* = $80000000 + ((-2100 - 3));
    illegalVoiceAllocationErr*    = $80000000 + ((-2100 - 4));
    illegalPartErr*                = $80000000 + ((-2100 - 5));
    illegalChannelErr*            = $80000000 + ((-2100 - 6));
    illegalKnobErr*                = $80000000 + ((-2100 - 7));
    illegalKnobValueErr*            = $80000000 + ((-2100 - 8));
    illegalInstrumentErr*        = $80000000 + ((-2100 - 9));
    illegalControllerErr*        = $80000000 + ((-2100 - 10));
    midiManagerAbsentErr*        = $80000000 + ((-2100 - 11));
    synthesizerNotRespondingErr*    = $80000000 + ((-2100 - 12));
    synthesizerErr*                = $80000000 + ((-2100 - 13));
    illegalNoteChannelErr*        = $80000000 + ((-2100 - 14));
    noteChannelNotAllocatedErr*    = $80000000 + ((-2100 - 15));
    tunePlayerFullErr*            = $80000000 + ((-2100 - 16));
    tuneParseErr*                = $80000000 + ((-2100 - 17));

    kGMType*                        = LONG("gm  ");

(*-----------------------------------------
    Capabilities and Voice Allocation
-----------------------------------------*)

PROCEDURE MusicGetPart*(mc: MusicComponent; part: LONGINT; VAR midiChannel: LONGINT; VAR polyphony: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $2, $7000, $A82A;
    (*$END*)
PROCEDURE MusicSetPart*(mc: MusicComponent; part: LONGINT; midiChannel: LONGINT; polyphony: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $3, $7000, $A82A;
    (*$END*)
PROCEDURE MusicGetDescription*(mc: MusicComponent; VAR sd: SynthesizerDescription): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $1, $7000, $A82A;
    (*$END*)
PROCEDURE MusicGetInstrumentAboutInfo*(mc: MusicComponent; part: LONGINT; VAR iai: InstrumentAboutInfo): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $22, $7000, $A82A;
    (*$END*)
(*-----------------------------------------
    Instrument Loading and Storing
-----------------------------------------*)
PROCEDURE MusicSetInstrumentNumber*(mc: MusicComponent; part: LONGINT; instrumentNumber: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $4, $7000, $A82A;
    (*$END*)
PROCEDURE MusicGetInstrumentNumber*(mc: MusicComponent; part: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $5, $7000, $A82A;
    (*$END*)
PROCEDURE MusicStoreInstrument*(mc: MusicComponent; part: LONGINT; instrumentNumber: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $6, $7000, $A82A;
    (*$END*)
PROCEDURE MusicGetInstrument*(mc: MusicComponent; part: LONGINT; VAR iH: InstrumentDataHandle): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $7, $7000, $A82A;
    (*$END*)
PROCEDURE MusicSetInstrument*(mc: MusicComponent; part: LONGINT; iH: InstrumentDataHandle): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $8, $7000, $A82A;
    (*$END*)
PROCEDURE MusicSetFlatInstrument*(mc: MusicComponent; part: LONGINT; VAR flatInstrument: FlatInstrument): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $21, $7000, $A82A;
    (*$END*)
(*-----------------------------------------
    Instrument Knobs
-----------------------------------------*)
PROCEDURE MusicGetInstrumentKnobDescription*(mc: MusicComponent; knobNumber: LONGINT; VAR mkd: KnobDescription): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $D, $7000, $A82A;
    (*$END*)
PROCEDURE MusicGetDrumKnobDescription*(mc: MusicComponent; knobNumber: LONGINT; VAR mkd: KnobDescription): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $E, $7000, $A82A;
    (*$END*)
PROCEDURE MusicGetPartKnob*(mc: MusicComponent; part: LONGINT; knobNumber: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $10, $7000, $A82A;
    (*$END*)
PROCEDURE MusicSetPartKnob*(mc: MusicComponent; part: LONGINT; knobNumber: LONGINT; knobValue: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $11, $7000, $A82A;
    (*$END*)
(*-----------------------------------------
    Synthesizer Knobs
-----------------------------------------*)
PROCEDURE MusicGetKnobDescription*(mc: MusicComponent; knobNumber: LONGINT; VAR mkd: KnobDescription): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $F, $7000, $A82A;
    (*$END*)
PROCEDURE MusicGetKnob*(mc: MusicComponent; knobNumber: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $12, $7000, $A82A;
    (*$END*)
PROCEDURE MusicSetKnob*(mc: MusicComponent; knobNumber: LONGINT; knobValue: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $13, $7000, $A82A;
    (*$END*)
PROCEDURE MusicSetMasterTune*(mc: MusicComponent; masterTune: Types.Fixed): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $20, $7000, $A82A;
    (*$END*)
PROCEDURE MusicGetMasterTune*(mc: MusicComponent): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, 0, $1F, $7000, $A82A;
    (*$END*)
(*-----------------------------------------
    Names of Instruments
-----------------------------------------*)
PROCEDURE MusicGetPartName*(mc: MusicComponent; part: LONGINT; VAR name: Types.Str31): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $14, $7000, $A82A;
    (*$END*)
PROCEDURE MusicSetPartName*(mc: MusicComponent; part: LONGINT; VAR name: Types.Str31): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $15, $7000, $A82A;
    (*$END*)
PROCEDURE MusicFindTone*(mc: MusicComponent; VAR td: ToneDescription; VAR instrumentNumber: LONGINT; VAR fit: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $16, $7000, $A82A;
    (*$END*)
PROCEDURE MusicGetInstrumentNames*(mc: MusicComponent; modifiableInstruments: LONGINT; VAR instrumentNames: Types.Handle; VAR instrumentCategoryLasts: Types.Handle; VAR instrumentCategoryNames: Types.Handle): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $10, $1D, $7000, $A82A;
    (*$END*)
PROCEDURE MusicGetDrumNames*(mc: MusicComponent; modifiableInstruments: LONGINT; VAR instrumentNumbers: Types.Handle; VAR instrumentNames: Types.Handle): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $1E, $7000, $A82A;
    (*$END*)
(*-----------------------------------------
    Realtime Actions
-----------------------------------------*)
PROCEDURE MusicPlayNote*(mc: MusicComponent; part: LONGINT; pitch: LONGINT; velocity: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $17, $7000, $A82A;
    (*$END*)
PROCEDURE MusicResetPart*(mc: MusicComponent; part: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $18, $7000, $A82A;
    (*$END*)
PROCEDURE MusicSetController*(mc: MusicComponent; part: LONGINT; controllerNumber: LONGINT; controllerValue: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $19, $7000, $A82A;
    (*$END*)
PROCEDURE MusicGetController*(mc: MusicComponent; part: LONGINT; controllerNumber: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $1A, $7000, $A82A;
    (*$END*)
(*-----------------------------------------
    Finding the Hardware
-----------------------------------------*)
PROCEDURE MusicGetMIDIProc*(mc: MusicComponent; VAR midiSendProc: MusicMIDISendUPP; VAR refCon: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $1B, $7000, $A82A;
    (*$END*)
PROCEDURE MusicSetMIDIProc*(mc: MusicComponent; midiSendProc: MusicMIDISendUPP; refCon: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $1C, $7000, $A82A;
    (*$END*)
(*--------------------------
    Types
--------------------------*)

TYPE
    NoteChannel* = Types.Ptr;

    SynthesizerConnections* = RECORD
        clientID*:                Types.OSType;
        inputPortID*:            Types.OSType;
        outputPortID*:            Types.OSType;
        midiChannel*:            LONGINT;                                (* The system channel; others are configurable (or the nubus slot number) *)
        flags*:                    LONGINT;
        reserved*:                ARRAY 3 (*ΔΔ[0..2]ΔΔ*) OF LONGINT;                (* should be zero *)
    END;

    NoteRequest* = RECORD
        polyphony*:                LONGINT;                                (* Maximum number of voices *)
        typicalPolyphony*:        Types.Fixed;                                    (* Hint for level mixing *)
        tone*:                    ToneDescription;
    END;


CONST
    kNAFirstSelector*            = -7;
    kNATargetSelect*                = -6;
    kNARegisterSelect*            = -5;
    kNAVersionSelect*            = -4;
    kNACanDoSelect*                = -3;
    kNACloseSelect*                = -2;
    kNAOpenSelect*                = -1;
    kNARegisterMusicDeviceSelect* = 0;
    kNAUnregisterMusicDeviceSelect* = 1;
    kNAGetRegisteredMusicDeviceSelect* = 2;
    kNASaveMusicConfigurationSelect* = 3;
    kNANewNoteChannelSelect*        = 4;
    kNADisposeNoteChannelSelect*    = 5;
    kNAGetNoteChannelInfoSelect*    = 6;
    kNAPrerollNoteChannelSelect*    = 7;
    kNAUnrollNoteChannelSelect*    = 8;
    kNAEngageNoteChannelSelect*    = 9;
    kNADisengageNoteChannelSelect* = 10;
    kNASetNoteChannelVolumeSelect* = 11;
    kNAResetNoteChannelSelect*    = 12;
    kNAPlayNoteSelect*            = 13;
    kNASetControllerSelect*        = 14;
    kNASetKnobSelect*            = 15;
    kNAFindNoteChannelToneSelect* = 16;
    kNASetNoteChannelInstrumentSelect* = 17;
    kNAPickInstrumentSelect*        = 18;
    kNAPickArrangementSelect*    = 19;
    kNAGetStatusBlockSelect*        = 20;
    kNASetDefaultMIDIInputSelect* = 21;
    kNAGetDefaultMIDIInputSelect* = 22;
    kNAGetNoteChannelStateSelect* = 23;
    kNASetNoteChannelStateSelect* = 24;
    kNAUseDefaultMIDIInputSelect* = 25;
    kNALoseDefaultMIDIInputSelect* = 26;
    kNAStuffToneDescriptionSelect* = 27;
    kNACopyrightDialogSelect*    = 28;
    kNASetFlatInstrumentSelect*    = 29;
    kNASetInstrumentSelect*        = 30;
    kNALastSelector*                = 31;


TYPE
    NoteAllocator* = Components.ComponentInstance;


CONST
    kPickDontMix*                = 1;                            (* dont mix instruments with drum sounds *)
    kPickSameSynth*                = 2;                            (* only allow the same device that went in, to come out *)

TYPE
    MusicMIDIReadHookProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (VAR mp: MusicMIDIPacket; myRefCon: LONGINT): Components.ComponentResult;
    MusicMIDIReadHookUPP* = Types.UniversalProcPtr;


CONST
    kNoteAllocatorType*            = LONG("nota");

(*--------------------------------
    Note Allocator Prototypes
--------------------------------*)
(*
 * System Configuration
 *)

PROCEDURE NARegisterMusicDevice*(na: NoteAllocator; synthType: Types.OSType; VAR name: Types.Str31; VAR connections: SynthesizerConnections): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, 0, $7000, $A82A;
    (*$END*)
PROCEDURE NAUnregisterMusicDevice*(na: NoteAllocator; index: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $1, $7000, $A82A;
    (*$END*)
PROCEDURE NAGetRegisteredMusicDevice*(na: NoteAllocator; index: LONGINT; VAR synthType: Types.OSType; VAR name: Types.Str31; VAR connections: SynthesizerConnections; VAR mc: MusicComponent): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $14, $2, $7000, $A82A;
    (*$END*)
PROCEDURE NASetDefaultMIDIInput*(na: NoteAllocator; VAR sc: SynthesizerConnections): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $15, $7000, $A82A;
    (*$END*)
PROCEDURE NAGetDefaultMIDIInput*(na: NoteAllocator; VAR sc: SynthesizerConnections): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $16, $7000, $A82A;
    (*$END*)
PROCEDURE NASaveMusicConfiguration*(na: NoteAllocator): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, 0, $3, $7000, $A82A;
    (*$END*)
(*
 * Allocation
 *)
PROCEDURE NANewNoteChannel*(na: NoteAllocator; VAR noteRequest: NoteRequest; VAR outChannel: NoteChannel): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $4, $7000, $A82A;
    (*$END*)
PROCEDURE NADisposeNoteChannel*(na: NoteAllocator; noteChannel: NoteChannel): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $5, $7000, $A82A;
    (*$END*)
PROCEDURE NAGetNoteChannelInfo*(na: NoteAllocator; noteChannel: NoteChannel; VAR index: LONGINT; VAR part: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $6, $7000, $A82A;
    (*$END*)
PROCEDURE NAUseDefaultMIDIInput*(na: NoteAllocator; readHook: MusicMIDIReadHookUPP; refCon: LONGINT; flags: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $19, $7000, $A82A;
    (*$END*)
PROCEDURE NALoseDefaultMIDIInput*(na: NoteAllocator): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, 0, $1A, $7000, $A82A;
    (*$END*)
(*
 * Setup
 *)
PROCEDURE NAPrerollNoteChannel*(na: NoteAllocator; noteChannel: NoteChannel): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $7, $7000, $A82A;
    (*$END*)
PROCEDURE NAUnrollNoteChannel*(na: NoteAllocator; noteChannel: NoteChannel): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $8, $7000, $A82A;
    (*$END*)
PROCEDURE NAEngageNoteChannel*(na: NoteAllocator; noteChannel: NoteChannel): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $9, $7000, $A82A;
    (*$END*)
PROCEDURE NADisengageNoteChannel*(na: NoteAllocator; noteChannel: NoteChannel; silenceNotes: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $A, $7000, $A82A;
    (*$END*)
PROCEDURE NAGetNoteChannelState*(na: NoteAllocator; noteChannel: NoteChannel; instrumentNumber: LONGINT; VAR state: Types.Handle): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $17, $7000, $A82A;
    (*$END*)
PROCEDURE NASetNoteChannelState*(na: NoteAllocator; noteChannel: NoteChannel; instrumentNumber: LONGINT; state: Types.Handle): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $18, $7000, $A82A;
    (*$END*)
PROCEDURE NAResetNoteChannel*(na: NoteAllocator; noteChannel: NoteChannel): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $C, $7000, $A82A;
    (*$END*)
PROCEDURE NASetNoteChannelVolume*(na: NoteAllocator; noteChannel: NoteChannel; volume: Types.Fixed): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $B, $7000, $A82A;
    (*$END*)
PROCEDURE NASetInstrument*(na: NoteAllocator; noteChannel: NoteChannel; VAR instrumentData: InstrumentData): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $1E, $7000, $A82A;
    (*$END*)
PROCEDURE NASetFlatInstrument*(na: NoteAllocator; noteChannel: NoteChannel; VAR flatInstrument: FlatInstrument): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $1D, $7000, $A82A;
    (*$END*)
(*
 * Control
 *)
PROCEDURE NAPlayNote*(na: NoteAllocator; noteChannel: NoteChannel; pitch: LONGINT; velocity: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $D, $7000, $A82A;
    (*$END*)
PROCEDURE NASetController*(na: NoteAllocator; noteChannel: NoteChannel; controllerNumber: LONGINT; controllerValue: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $E, $7000, $A82A;
    (*$END*)
PROCEDURE NASetKnob*(na: NoteAllocator; noteChannel: NoteChannel; knobNumber: LONGINT; knobValue: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $F, $7000, $A82A;
    (*$END*)
PROCEDURE NAFindNoteChannelTone*(na: NoteAllocator; noteChannel: NoteChannel; VAR td: ToneDescription; VAR instrumentNumber: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $10, $7000, $A82A;
    (*$END*)
PROCEDURE NASetNoteChannelInstrument*(na: NoteAllocator; noteChannel: NoteChannel; instrumentNumber: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $11, $7000, $A82A;
    (*$END*)
(*
 * User Interface
 *)
PROCEDURE NAPickInstrument*(na: NoteAllocator; filterProc: Dialogs.ModalFilterUPP; prompt: Types.StringPtr; VAR sd: ToneDescription; flags: LONGINT; refCon: LONGINT; VAR flatList: Types.Ptr; VAR flatChoiceIndex: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $1C, $12, $7000, $A82A;
    (*$END*)
PROCEDURE NAStuffToneDescription*(na: NoteAllocator; gmNumber: LONGINT; VAR td: ToneDescription): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $1B, $7000, $A82A;
    (*$END*)
PROCEDURE NAPickArrangement*(na: NoteAllocator; filterProc: Dialogs.ModalFilterUPP; prompt: Types.StringPtr; partCount: LONGINT; VAR noteRequestList: NoteRequest; t: Movies.Track; songName: Types.StringPtr): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $18, $13, $7000, $A82A;
    (*$END*)
PROCEDURE NACopyrightDialog*(na: NoteAllocator; p: Quickdraw.PicHandle; author: Types.StringPtr; copyright: Types.StringPtr; other: Types.StringPtr; title: Types.StringPtr; filterProc: Dialogs.ModalFilterUPP; refCon: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $1C, $1C, $7000, $A82A;
    (*$END*)
(*
 * Note Allocator interior views
 *)

TYPE
    NAStatPiece* = RECORD
        clientName*:                Types.Str31;
        synthesizerName*:        Types.Str31;
        part*:                    LONGINT;
        midiChannel*:            LONGINT;
        polyphony*:                LONGINT;
        valid*:                    LONGINT;
    END;

    NAStat* = RECORD
        pieceCount*:                LONGINT;
        piece*:                    ARRAY 64 (*ΔΔ[0..63]ΔΔ*) OF NAStatPiece;
    END;


PROCEDURE NAGetStatusBlock*(na: NoteAllocator; VAR stat: NAStat): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $14, $7000, $A82A;
    (*$END*)
(*--------------------------
    Types
--------------------------*)

CONST
    kTuneQueueDepth*                = 8;                            (* Deepest you can queue tune segments *)


TYPE
    TuneStatus* = RECORD
        tune*:                    SYSTEM.PTR (*ΔΔ POINTER TO LONGINT*);                                (* currently playing tune *)
        tunePtr*:                SYSTEM.PTR (*ΔΔ POINTER TO LONGINT*);                                (* position within currently playing piece *)
        time*:                    Movies.TimeValue;                                (* current tune time *)
        queueCount*:                INTEGER;                                (* how many pieces queued up? *)
        queueSpots*:                INTEGER;                                (* How many more tunepieces can be queued *)
        queueTime*:                Movies.TimeValue;                                (* How much time is queued up? (can be very inaccurate) *)
        reserved*:                ARRAY 3 (*ΔΔ[0..2]ΔΔ*) OF LONGINT;
    END;


CONST
    kStopTuneFade*                = 1;                            (* do a quick, synchronous fadeout *)
    kStopTuneSustain*            = 2;                            (* don't silece notes *)
    kStopTuneInstant*            = 4;                            (* silence notes fast (else, decay them) *)
    kStopTuneReleaseChannels*    = 8;                            (* afterwards, let the channels go *)

    kTuneSelect*                    = 3;
    kTuneSetHeaderSelect*        = 4;
    kTuneGetTimeBaseSelect*        = 5;
    kTuneSetTimeScaleSelect*        = 6;
    kTuneGetTimeScaleSelect*        = 7;
    kTuneGetIndexedNoteChannelSelect* = 8;
    kTuneDummy*                    = 9;
    kTuneQueueSelect*            = 10;
    kTuneInstantSelect*            = 11;
    kTuneGetStatusSelect*        = 12;
    kTuneStopSelect*                = 13;
    kTuneResumeSelect*            = 14;
    kTuneFlushSelect*            = 15;
    kTuneSetVolumeSelect*        = 16;
    kTuneGetVolumeSelect*        = 17;
    kTunePrerollSelect*            = 18;
    kTuneUnrollSelect*            = 19;
    kTuneLastSelector*            = 20;

TYPE
    TuneCallBackProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE ((*CONST*)VAR status: TuneStatus; refCon: LONGINT);
    TunePlayCallBackProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (VAR event: LONGINT; seed: LONGINT; refCon: LONGINT);
    TuneCallBackUPP* = Types.UniversalProcPtr;
    TunePlayCallBackUPP* = Types.UniversalProcPtr;

    TunePlayer* = Components.ComponentInstance;


CONST
    kMaxTunePlayerParts*            = 32;
    kTunePlayerType*                = LONG("tune");

(*--------------------------
    Prototypes
--------------------------*)

PROCEDURE TuneSetHeader*(tp: TunePlayer; VAR header: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $4, $7000, $A82A;
    (*$END*)
PROCEDURE TuneGetTimeBase*(tp: TunePlayer; VAR tb: Movies.TimeBase): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $5, $7000, $A82A;
    (*$END*)
PROCEDURE TuneSetTimeScale*(tp: TunePlayer; scale: Movies.TimeScale): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $6, $7000, $A82A;
    (*$END*)
PROCEDURE TuneGetTimeScale*(tp: TunePlayer; VAR scale: Movies.TimeScale): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $7, $7000, $A82A;
    (*$END*)
PROCEDURE TuneGetIndexedNoteChannel*(tp: TunePlayer; i: LONGINT; VAR nc: NoteChannel): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $8, $7000, $A82A;
    (*$END*)
(* Values for when to start. *)

CONST
    kTuneStartNow*                = 1;                            (* start after buffer is implied *)
    kTuneDontClipNotes*            = 2;                            (* allow notes to finish their durations outside sample *)
    kTuneExcludeEdgeNotes*        = 4;                            (* dont play notes that start at end of tune *)
    kTuneStartNewMaster*            = 16384;


PROCEDURE TuneQueue*(tp: TunePlayer; VAR tune: LONGINT; tuneRate: Types.Fixed; tuneStartPosition: LONGINT; tuneStopPosition: LONGINT; queueFlags: LONGINT; callBackProc: TuneCallBackUPP; refCon: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $1C, $A, $7000, $A82A;
    (*$END*)
PROCEDURE TuneInstant*(tp: TunePlayer; VAR tune: LONGINT; tunePosition: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $B, $7000, $A82A;
    (*$END*)
PROCEDURE TuneGetStatus*(tp: TunePlayer; VAR status: TuneStatus): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $C, $7000, $A82A;
    (*$END*)
(* Values for when to start. *)

CONST
    kStopSustain*                = 1;                            (* Leaves notes playing, not silent *)
    kStopFadeout*                = 2;                            (* Does a synchronous fade-out *)


PROCEDURE TuneStop*(tp: TunePlayer; stopFlags: LONGINT): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $D, $7000, $A82A;
    (*$END*)
PROCEDURE TuneResume*(tp: TunePlayer): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, 0, $E, $7000, $A82A;
    (*$END*)
PROCEDURE TuneFlush*(tp: TunePlayer): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, 0, $F, $7000, $A82A;
    (*$END*)
PROCEDURE TuneSetVolume*(tp: TunePlayer; volume: Types.Fixed): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $10, $7000, $A82A;
    (*$END*)
PROCEDURE TuneGetVolume*(tp: TunePlayer): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, 0, $11, $7000, $A82A;
    (*$END*)
PROCEDURE TunePreroll*(tp: TunePlayer): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, 0, $12, $7000, $A82A;
    (*$END*)
PROCEDURE TuneUnroll*(tp: TunePlayer): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, 0, $13, $7000, $A82A;
    (*$END*)

TYPE
    MusicOpWord* = LONGINT;
    MusicOpWordPtr* = SYSTEM.PTR (*ΔΔ POINTER TO LONGINT*);

(*     QuickTime Music Movies.Track Event Formats:

    At this time, QuickTime music tracks support 5 different event types -- REST events,
    short NOTE events, short CONTROL events, short GENERAL events, Long NOTE events,
    long CONTROL events, and variable GENERAL events.

        • REST Event (4 bytes/event):

            (0 0 0) (5-bit UNUSED) (24-bit Rest Duration)

        • Short NOTE Events (4 bytes/event):

            (0 0 1) (5-bit Instrument) (6-bit Pitch) (7-bit Volume) (11-bit Duration)

            where:    Pitch is offset by 32 (Actual pitch* = pitch field + 32)

        • Short CONTROL Events (4 bytes/event):

            (0 1 0) (5-bit Instrument) (8-bit Controller) (1-bit UNUSED) (1-bit Sign) (7-bit MSB) (7-bit LSB)
                                                                         ( or 15-bit Signed Value)
        • Short GENERAL Event (4 bytes/event):

            (0 1 1) (1-bit UNUSED) (12-bit Sub-Type) (16-bit Value)

        • Long NOTE Events (8 bytes/event):

            (1 0 0 1) (12-bit Instrument) (1-bit UNUSED) (7-bit Pitch) (1-bit UNUSED) (7-bit Volume)
            (1 0) (8-bit UNUSED) (22-bit Duration)

        • Long CONTROL Event (8 bytes/event):

            (1 0 1 0) (12-bit Instrument) (16-bit Value MSB)
            (1 0) (14-bit Controller) (16-bit Value LSB)

        • Long KNOB Event (8 bytes/event):

            (1 0 1 1) (12-bit Sub-Type) (16-bit Value MSB)
            (1 0) (14-bit KNOB) (16-bit Value LSB)

        • Variable GENERAL Length Events (N bytes/event):

            (1 1 1 1) (12-bit Sub-Type) (16-bit Length)
                :
            (32-bit Data values)
                :
            (1 1) (14-bit UNUSED) (16-bit Length)

            where:    Length field is the number of LONG words in the record.
                    Lengths include the first and last long words (Minimum length* = 2)

    The following event type values have not been used yet and are reserved for
    future expansion:

        • (1 0 0 0)        (8 bytes/event)
        • (1 1 0 0)        (N bytes/event)
        • (1 1 0 1)        (N bytes/event)
        • (1 1 1 0)        (N bytes/event)

    For all events, the following generalizations apply:

        -    All duration values are specified in Millisecond units.
        -     Pitch values are intended to map directly to the MIDI key numbers.
        -    Controllers from 0 to 127 correspond to the standard MIDI controllers.
            Controllers greater than 127 correspond to other controls (i.e., Pitch Bend,
            Key Pressure, and Channel Pressure).
*)
(* Defines for the implemented music event data fields*)

CONST
    kRestEventType*                = $0;                            (* lower 3-bits *)
    kNoteEventType*                = $1;                            (* lower 3-bits *)
    kControlEventType*            = $2;                            (* lower 3-bits *)
    kMarkerEventType*            = $3;                            (* lower 3-bits *)
    kUndefined1EventType*        = $8;                            (* 4-bits *)
    kXNoteEventType*                = $9;                            (* 4-bits *)
    kXControlEventType*            = $A;                            (* 4-bits *)
    kKnobEventType*                = $B;                            (* 4-bits *)
    kUndefined2EventType*        = $C;                            (* 4-bits *)
    kUndefined3EventType*        = $D;                            (* 4-bits *)
    kUndefined4EventType*        = $E;                            (* 4-bits *)
    kGeneralEventType*            = $F;                            (* 4-bits *)
    kXEventLengthBits*            = $2;                            (* 2 bits: indicates 8-byte event record *)
    kGeneralEventLengthBits*        = $3;                            (* 2 bits: indicates variable length event record *)
    kEventLen*                    = 1;                            (* length of events in long words *)
    kXEventLen*                    = 2;
    kRestEventLen*                = kEventLen;                    (* length of events in long words *)
    kNoteEventLen*                = kEventLen;
    kControlEventLen*            = kEventLen;
    kMarkerEventLen*                = kEventLen;
    kXNoteEventLen*                = kXEventLen;
    kXControlEventLen*            = kXEventLen;
    kGeneralEventLen*            = kXEventLen;                    (* 2 or more, however *)
(* Universal Event Defines*)
    kEventLengthFieldPos*        = 30;                            (* by looking at these two bits of the 1st or last word              *)
    kEventLengthFieldWidth*        = 2;                            (* of an event you can determine the event length                      *)
(* length field: 0 & 1 => 1 long; 2 => 2 longs; 3 => variable length *)
    kEventTypeFieldPos*            = 29;                            (* event type field for short events *)
    kEventTypeFieldWidth*        = 3;                            (* short type is 3 bits *)
    kXEventTypeFieldPos*            = 28;                            (* event type field for extended events *)
    kXEventTypeFieldWidth*        = 4;                            (* extended type is 4 bits *)
    kEventInstrumentFieldPos*    = 24;
    kEventInstrumentFieldWidth*    = 5;
    kXEventInstrumentFieldPos*    = 16;                            (* in the 1st long word *)
    kXEventInstrumentFieldWidth*    = 12;
(* Rest Events*)
    kRestEventDurationFieldPos*    = 0;
    kRestEventDurationFieldWidth* = 24;
    kRestEventDurationMax*        = ASH(1,kRestEventDurationFieldWidth) - 1;
(* Note Events*)
    kNoteEventPitchFieldPos*        = 18;
    kNoteEventPitchFieldWidth*    = 6;
    kNoteEventPitchOffset*        = 32;                            (* add to value in pitch field to get actual pitch *)
    kNoteEventVolumeFieldPos*    = 11;
    kNoteEventVolumeFieldWidth*    = 7;
    kNoteEventVolumeOffset*        = 0;                            (* add to value in volume field to get actual volume *)
    kNoteEventDurationFieldPos*    = 0;
    kNoteEventDurationFieldWidth* = 11;
    kNoteEventDurationMax*        = ASH(1,kNoteEventDurationFieldWidth) - 1;
    kXNoteEventPitchFieldPos*    = 0;                            (* in the 1st long word *)
    kXNoteEventPitchFieldWidth*    = 16;
    kXNoteEventDurationFieldPos*    = 0;                            (* in the 2nd long word *)
    kXNoteEventDurationFieldWidth* = 22;
    kXNoteEventDurationMax*        = ASH(1,kXNoteEventDurationFieldWidth) - 1;
    kXNoteEventVolumeFieldPos*    = 22;                            (* in the 2nd long word *)
    kXNoteEventVolumeFieldWidth*    = 7;
(* Control Events*)
    kControlEventControllerFieldPos* = 16;
    kControlEventControllerFieldWidth* = 8;
    kControlEventValueFieldPos*    = 0;
    kControlEventValueFieldWidth* = 16;
    kXControlEventControllerFieldPos* = 0;                        (* in the 2nd long word *)
    kXControlEventControllerFieldWidth* = 16;
    kXControlEventValueFieldPos*    = 0;                            (* in the 1st long word *)
    kXControlEventValueFieldWidth* = 16;
(* Knob Events*)
    kKnobEventValueHighFieldPos*    = 0;                            (* 1st long word *)
    kKnobEventValueHighFieldWidth* = 16;
    kKnobEventKnobFieldPos*        = 16;                            (* 2nd long word *)
    kKnobEventKnobFieldWidth*    = 14;
    kKnobEventValueLowFieldPos*    = 0;                            (* 2nd long word *)
    kKnobEventValueLowFieldWidth* = 16;
(* AIFF.Marker Events*)
    kMarkerEventSubtypeFieldPos*    = 16;
    kMarkerEventSubtypeFieldWidth* = 8;
    kMarkerEventValueFieldPos*    = 0;
    kMarkerEventValueFieldWidth*    = 16;
(* General Events*)
    kGeneralEventSubtypeFieldPos* = 16;                            (* in the last long word *)
    kGeneralEventSubtypeFieldWidth* = 14;
    kGeneralEventLengthFieldPos*    = 0;                            (* in the 1st & last long words *)
    kGeneralEventLengthFieldWidth* = 16;

    kGeneralEventNoteRequest*    = 1;                            (* Encapsulates NoteRequest data structure *)
    kGeneralEventInstrument*        = 2;                            (* Encapsulates poly, typical poly, followed by InstrumentData record *)
    kGeneralEventFlatInstrument*    = 3;                            (* Encapsulates poly, typical poly, followed by FlatInstrument record *)
    kGeneralEventPartName*        = 4;                            (* Brackets 2 longs follwed by a pascal string (padded to long alignment) *)
    kGeneralEventPartKey*        = 5;                            (* Brackets 2 longs *)

    TCSourceRefNameType*            = LONG("name");

    tcDropFrame*                    = ASH(1,0);
    tc24HourMax*                    = ASH(1,1);
    tcNegTimesOK*                = ASH(1,2);
    tcCounter*                    = ASH(1,3);


TYPE
    TimeCodeDef* = RECORD
        flags*:                    LONGINT;                                (* drop-frame, etc.*)
        fTimeScale*:                Movies.TimeScale;                                (* time scale of frameDuration (eg. 2997)*)
        frameDuration*:            Movies.TimeValue;                                (* duration of each frame (eg. 100)*)
        numFrames*:                Types.SInt8; (* UInt8 *)                        (* number of frames per second for timecode (eg. 30)*)
        (* number of frames per tick for counter mode*)
        padding*:                Types.SInt8; (* UInt8 *)                        (* unused padding byte *)
    END;


CONST
    tctNegFlag*                    = $80;                            (* negative bit is in minutes*)


TYPE
    TimeCodeTime* = RECORD
        hours*:                    Types.SInt8; (* UInt8 *)
        minutes*:                Types.SInt8; (* UInt8 *)
        seconds*:                Types.SInt8; (* UInt8 *)
        frames*:                    Types.SInt8; (* UInt8 *)
    END;

    TimeCodeCounter* = RECORD
        counter*:                LONGINT;
    END;

    TimeCodeRecord* = RECORD
        (*ΔΔ CASE INTEGER OF
        0: ( *)
            t*:                            TimeCodeTime;
           (*ΔΔ );
        1: (
            c*:                            TimeCodeCounter;
           );*)
    END;

    TimeCodeDescription* = RECORD
        (* standard sample description header*)
        descSize*:                LONGINT;
        dataFormat*:                LONGINT;
        resvd1*:                    LONGINT;
        resvd2*:                    INTEGER;
        dataRefIndex*:            INTEGER;
        (* timecode specific stuff*)
        flags*:                    LONGINT;
        timeCodeDef*:            TimeCodeDef;
        srcRef*:                    ARRAY 1 (*ΔΔ[0..0]ΔΔ*) OF LONGINT;
    END;

    TimeCodeDescriptionPtr* = POINTER TO TimeCodeDescription;

    TimeCodeDescriptionHandle* = HANDLE TO TimeCodeDescription (*ΔΔ POINTER TO TimeCodeDescriptionPtr*);


CONST
    tcdfShowTimeCode*            = ASH(1,0);

    kTCGetCurrentTimeCodeSelect*    = 257;
    kTCGetTimeCodeAtTimeSelect*    = 258;
    kTCTimeCodeToStringSelect*    = 259;
    kTCTimeCodeToFrameNumberSelect* = 260;
    kTCFrameNumberToTimeCodeSelect* = 261;
    kTCGetSourceRefSelect*        = 262;
    kTCSetSourceRefSelect*        = 263;
    kTCSetTimeCodeFlagsSelect*    = 264;
    kTCGetTimeCodeFlagsSelect*    = 265;
    kTCSetDisplayOptionsSelect*    = 266;
    kTCGetDisplayOptionsSelect*    = 267;


TYPE
    TCTextOptions* = RECORD
        txFont*:                    INTEGER;
        txFace*:                    INTEGER;
        txSize*:                    INTEGER;
        foreColor*:                Quickdraw.RGBColor;
        backColor*:                Quickdraw.RGBColor;
    END;

    TCTextOptionsPtr* = POINTER TO TCTextOptions;


PROCEDURE TCGetCurrentTimeCode*(mh: Movies.MediaHandler; VAR frameNum: LONGINT; VAR tcdef: TimeCodeDef; VAR tcrec: TimeCodeRecord; VAR srcRefH: Movies.UserData): Movies.HandlerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $10, $101, $7000, $A82A;
    (*$END*)
PROCEDURE TCGetTimeCodeAtTime*(mh: Movies.MediaHandler; mediaTime: Movies.TimeValue; VAR frameNum: LONGINT; VAR tcdef: TimeCodeDef; VAR tcdata: TimeCodeRecord; VAR srcRefH: Movies.UserData): Movies.HandlerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $14, $102, $7000, $A82A;
    (*$END*)
PROCEDURE TCTimeCodeToFrameNumber*(mh: Movies.MediaHandler; VAR tcdef: TimeCodeDef; VAR tcrec: TimeCodeRecord; VAR frameNumber: LONGINT): Movies.HandlerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $104, $7000, $A82A;
    (*$END*)
PROCEDURE TCFrameNumberToTimeCode*(mh: Movies.MediaHandler; frameNumber: LONGINT; VAR tcdef: TimeCodeDef; VAR tcrec: TimeCodeRecord): Movies.HandlerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $105, $7000, $A82A;
    (*$END*)
PROCEDURE TCTimeCodeToString*(mh: Movies.MediaHandler; VAR tcdef: TimeCodeDef; VAR tcrec: TimeCodeRecord; tcStr: Types.StringPtr): Movies.HandlerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $103, $7000, $A82A;
    (*$END*)
PROCEDURE TCGetSourceRef*(mh: Movies.MediaHandler; tcdH: TimeCodeDescriptionHandle; VAR srefH: Movies.UserData): Movies.HandlerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $106, $7000, $A82A;
    (*$END*)
PROCEDURE TCSetSourceRef*(mh: Movies.MediaHandler; tcdH: TimeCodeDescriptionHandle; srefH: Movies.UserData): Movies.HandlerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $107, $7000, $A82A;
    (*$END*)
PROCEDURE TCSetTimeCodeFlags*(mh: Movies.MediaHandler; flags: LONGINT; flagsMask: LONGINT): Movies.HandlerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $108, $7000, $A82A;
    (*$END*)
PROCEDURE TCGetTimeCodeFlags*(mh: Movies.MediaHandler; VAR flags: LONGINT): Movies.HandlerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $109, $7000, $A82A;
    (*$END*)
PROCEDURE TCSetDisplayOptions*(mh: Movies.MediaHandler; textOptions: TCTextOptionsPtr): Movies.HandlerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $10A, $7000, $A82A;
    (*$END*)
PROCEDURE TCGetDisplayOptions*(mh: Movies.MediaHandler; textOptions: TCTextOptionsPtr): Movies.HandlerError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $10B, $7000, $A82A;
    (*$END*)
(* UPP call backs *)

CONST
    uppSGDataProcInfo* = $003BFFE0; (* PROCEDURE (4 byte param, 4 byte param, 4 byte param, 4 byte param, 4 byte param, 4 byte param, 2 byte param, 4 byte param): 2 byte result; *)
    uppSGModalFilterProcInfo* = $00003FD0; (* PROCEDURE (4 byte param, 4 byte param, 4 byte param, 4 byte param): 1 byte result; *)
    uppSGGrabProcInfo* = $00000EF0; (* PROCEDURE (4 byte param, 2 byte param, 4 byte param): 4 byte result; *)
    uppSGGrabCompleteProcInfo* = $00003EF0; (* PROCEDURE (4 byte param, 2 byte param, 4 byte param, 4 byte param): 4 byte result; *)
    uppSGDisplayProcInfo* = $0000FEF0; (* PROCEDURE (4 byte param, 2 byte param, 4 byte param, 4 byte param, 4 byte param): 4 byte result; *)
    uppSGCompressProcInfo* = $00000EF0; (* PROCEDURE (4 byte param, 2 byte param, 4 byte param): 4 byte result; *)
    uppSGCompressCompleteProcInfo* = $0000FEF0; (* PROCEDURE (4 byte param, 2 byte param, 4 byte param, 4 byte param, 4 byte param): 4 byte result; *)
    uppSGAddFrameProcInfo* = $0003FEF0; (* PROCEDURE (4 byte param, 2 byte param, 4 byte param, 4 byte param, 4 byte param, 4 byte param): 4 byte result; *)
    uppSGTransferFrameProcInfo* = $0000FEF0; (* PROCEDURE (4 byte param, 2 byte param, 4 byte param, 4 byte param, 4 byte param): 4 byte result; *)
    uppSGGrabCompressCompleteProcInfo* = $0000FFF0; (* PROCEDURE (4 byte param, 4 byte param, 4 byte param, 4 byte param, 4 byte param): 4 byte result; *)
    uppSGDisplayCompressProcInfo* = $0003FFF0; (* PROCEDURE (4 byte param, 4 byte param, 4 byte param, 4 byte param, 4 byte param, 4 byte param): 4 byte result; *)
    uppVdigIntProcInfo* = $000003C0; (* PROCEDURE (4 byte param, 4 byte param); *)
    uppSCModalFilterProcInfo* = $00003FD0; (* PROCEDURE (4 byte param, 4 byte param, 4 byte param, 4 byte param): 1 byte result; *)
    uppSCModalHookProcInfo* = $00003EE0; (* PROCEDURE (4 byte param, 2 byte param, 4 byte param, 4 byte param): 2 byte result; *)
    uppDataHCompletionProcInfo* = $00000BC0; (* PROCEDURE (4 byte param, 4 byte param, 2 byte param); *)
    uppMusicMIDISendProcInfo* = $00000FF0; (* PROCEDURE (4 byte param, 4 byte param, 4 byte param): 4 byte result; *)
    uppMusicMIDIReadHookProcInfo* = $000003F0; (* PROCEDURE (4 byte param, 4 byte param): 4 byte result; *)
    uppTuneCallBackProcInfo* = $000003C0; (* PROCEDURE (4 byte param, 4 byte param); *)
    uppTunePlayCallBackProcInfo* = $00000FC0; (* PROCEDURE (4 byte param, 4 byte param, 4 byte param); *)

PROCEDURE NewSGDataProc*(userRoutine: SGDataProcPtr): SGDataUPP;
    (*$IF NOT GENERATINGCFM *)
    INLINE PASCAL $2E9F;
    (*$END*)

PROCEDURE NewSGModalFilterProc*(userRoutine: SGModalFilterProcPtr): SGModalFilterUPP;
    (*$IF NOT GENERATINGCFM *)
    INLINE PASCAL $2E9F;
    (*$END*)

PROCEDURE NewSGGrabProc*(userRoutine: SGGrabProcPtr): SGGrabUPP;
    (*$IF NOT GENERATINGCFM *)
    INLINE PASCAL $2E9F;
    (*$END*)

PROCEDURE NewSGGrabCompleteProc*(userRoutine: SGGrabCompleteProcPtr): SGGrabCompleteUPP;
    (*$IF NOT GENERATINGCFM *)
    INLINE PASCAL $2E9F;
    (*$END*)

PROCEDURE NewSGDisplayProc*(userRoutine: SGDisplayProcPtr): SGDisplayUPP;
    (*$IF NOT GENERATINGCFM *)
    INLINE PASCAL $2E9F;
    (*$END*)

PROCEDURE NewSGCompressProc*(userRoutine: SGCompressProcPtr): SGCompressUPP;
    (*$IF NOT GENERATINGCFM *)
    INLINE PASCAL $2E9F;
    (*$END*)

PROCEDURE NewSGCompressCompleteProc*(userRoutine: SGCompressCompleteProcPtr): SGCompressCompleteUPP;
    (*$IF NOT GENERATINGCFM *)
    INLINE PASCAL $2E9F;
    (*$END*)

PROCEDURE NewSGAddFrameProc*(userRoutine: SGAddFrameProcPtr): SGAddFrameUPP;
    (*$IF NOT GENERATINGCFM *)
    INLINE PASCAL $2E9F;
    (*$END*)

PROCEDURE NewSGTransferFrameProc*(userRoutine: SGTransferFrameProcPtr): SGTransferFrameUPP;
    (*$IF NOT GENERATINGCFM *)
    INLINE PASCAL $2E9F;
    (*$END*)

PROCEDURE NewSGGrabCompressCompleteProc*(userRoutine: SGGrabCompressCompleteProcPtr): SGGrabCompressCompleteUPP;
    (*$IF NOT GENERATINGCFM *)
    INLINE PASCAL $2E9F;
    (*$END*)

PROCEDURE NewSGDisplayCompressProc*(userRoutine: SGDisplayCompressProcPtr): SGDisplayCompressUPP;
    (*$IF NOT GENERATINGCFM *)
    INLINE PASCAL $2E9F;
    (*$END*)

PROCEDURE NewVdigIntProc*(userRoutine: VdigIntProcPtr): VdigIntUPP;
    (*$IF NOT GENERATINGCFM *)
    INLINE PASCAL $2E9F;
    (*$END*)

PROCEDURE NewSCModalFilterProc*(userRoutine: SCModalFilterProcPtr): SCModalFilterUPP;
    (*$IF NOT GENERATINGCFM *)
    INLINE PASCAL $2E9F;
    (*$END*)

PROCEDURE NewSCModalHookProc*(userRoutine: SCModalHookProcPtr): SCModalHookUPP;
    (*$IF NOT GENERATINGCFM *)
    INLINE PASCAL $2E9F;
    (*$END*)

PROCEDURE NewDataHCompletionProc*(userRoutine: DataHCompletionProcPtr): DataHCompletionUPP;
    (*$IF NOT GENERATINGCFM *)
    INLINE PASCAL $2E9F;
    (*$END*)

PROCEDURE NewMusicMIDISendProc*(userRoutine: MusicMIDISendProcPtr): MusicMIDISendUPP;
    (*$IF NOT GENERATINGCFM *)
    INLINE PASCAL $2E9F;
    (*$END*)

PROCEDURE NewMusicMIDIReadHookProc*(userRoutine: MusicMIDIReadHookProcPtr): MusicMIDIReadHookUPP;
    (*$IF NOT GENERATINGCFM *)
    INLINE PASCAL $2E9F;
    (*$END*)

PROCEDURE NewTuneCallBackProc*(userRoutine: TuneCallBackProcPtr): TuneCallBackUPP;
    (*$IF NOT GENERATINGCFM *)
    INLINE PASCAL $2E9F;
    (*$END*)

PROCEDURE NewTunePlayCallBackProc*(userRoutine: TunePlayCallBackProcPtr): TunePlayCallBackUPP;
    (*$IF NOT GENERATINGCFM *)
    INLINE PASCAL $2E9F;
    (*$END*)

PROCEDURE CallSGDataProc*(c: SGChannel; p: Types.Ptr; len: LONGINT; VAR offset: LONGINT; chRefCon: LONGINT; time: Movies.TimeValue; writeType: INTEGER; refCon: LONGINT; userRoutine: SGDataUPP): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $205F, $4E90;
    (*$END*)

PROCEDURE CallSGModalFilterProc*(theDialog: Dialogs.DialogPtr; VAR theEvent: Events.EventRecord; VAR itemHit: INTEGER; refCon: LONGINT; userRoutine: SGModalFilterUPP): BOOLEAN;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $205F, $4E90;
    (*$END*)

PROCEDURE CallSGGrabProc*(c: SGChannel; bufferNum: INTEGER; refCon: LONGINT; userRoutine: SGGrabUPP): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $205F, $4E90;
    (*$END*)

PROCEDURE CallSGGrabCompleteProc*(c: SGChannel; bufferNum: INTEGER; VAR done: BOOLEAN; refCon: LONGINT; userRoutine: SGGrabCompleteUPP): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $205F, $4E90;
    (*$END*)

PROCEDURE CallSGDisplayProc*(c: SGChannel; bufferNum: INTEGER; VAR mp: ImageCompression.MatrixRecord; clipRgn: Quickdraw.RgnHandle; refCon: LONGINT; userRoutine: SGDisplayUPP): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $205F, $4E90;
    (*$END*)

PROCEDURE CallSGCompressProc*(c: SGChannel; bufferNum: INTEGER; refCon: LONGINT; userRoutine: SGCompressUPP): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $205F, $4E90;
    (*$END*)

PROCEDURE CallSGCompressCompleteProc*(c: SGChannel; bufferNum: INTEGER; VAR done: BOOLEAN; VAR ci: SGCompressInfo; refCon: LONGINT; userRoutine: SGCompressCompleteUPP): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $205F, $4E90;
    (*$END*)

PROCEDURE CallSGAddFrameProc*(c: SGChannel; bufferNum: INTEGER; atTime: Movies.TimeValue; scale: Movies.TimeScale; (*CONST*)VAR ci: SGCompressInfo; refCon: LONGINT; userRoutine: SGAddFrameUPP): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $205F, $4E90;
    (*$END*)

PROCEDURE CallSGTransferFrameProc*(c: SGChannel; bufferNum: INTEGER; VAR mp: ImageCompression.MatrixRecord; clipRgn: Quickdraw.RgnHandle; refCon: LONGINT; userRoutine: SGTransferFrameUPP): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $205F, $4E90;
    (*$END*)

PROCEDURE CallSGGrabCompressCompleteProc*(c: SGChannel; VAR done: BOOLEAN; VAR ci: SGCompressInfo; VAR t: Movies.TimeRecord; refCon: LONGINT; userRoutine: SGGrabCompressCompleteUPP): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $205F, $4E90;
    (*$END*)

PROCEDURE CallSGDisplayCompressProc*(c: SGChannel; dataPtr: Types.Ptr; desc: ImageCompression.ImageDescriptionHandle; VAR mp: ImageCompression.MatrixRecord; clipRgn: Quickdraw.RgnHandle; refCon: LONGINT; userRoutine: SGDisplayCompressUPP): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $205F, $4E90;
    (*$END*)

PROCEDURE CallVdigIntProc*(flags: LONGINT; refcon: LONGINT; userRoutine: VdigIntUPP);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $205F, $4E90;
    (*$END*)

PROCEDURE CallSCModalFilterProc*(theDialog: Dialogs.DialogPtr; VAR theEvent: Events.EventRecord; VAR itemHit: INTEGER; refcon: LONGINT; userRoutine: SCModalFilterUPP): BOOLEAN;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $205F, $4E90;
    (*$END*)

PROCEDURE CallSCModalHookProc*(theDialog: Dialogs.DialogPtr; itemHit: INTEGER; params: (*ΔΔUNIVΔΔ*) Types.Ptr; refcon: LONGINT; userRoutine: SCModalHookUPP): INTEGER;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $205F, $4E90;
    (*$END*)

PROCEDURE CallDataHCompletionProc*(request: Types.Ptr; refcon: LONGINT; err: Types.OSErr; userRoutine: DataHCompletionUPP);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $205F, $4E90;
    (*$END*)

PROCEDURE CallMusicMIDISendProc*(self: MusicComponent; refCon: LONGINT; VAR mmp: MusicMIDIPacket; userRoutine: MusicMIDISendUPP): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $205F, $4E90;
    (*$END*)

PROCEDURE CallMusicMIDIReadHookProc*(VAR mp: MusicMIDIPacket; myRefCon: LONGINT; userRoutine: MusicMIDIReadHookUPP): Components.ComponentResult;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $205F, $4E90;
    (*$END*)

PROCEDURE CallTuneCallBackProc*((*CONST*)VAR status: TuneStatus; refCon: LONGINT; userRoutine: TuneCallBackUPP);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $205F, $4E90;
    (*$END*)

PROCEDURE CallTunePlayCallBackProc*(VAR event: LONGINT; seed: LONGINT; refCon: LONGINT; userRoutine: TunePlayCallBackUPP);
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $205F, $4E90;
    (*$END*)

(* $ALIGN RESET*)
(* $POP*)

 END QuickTimeComponents.